#Kerfio Standalone Slicing System Using PrusaSlicer Engine

#Purpose

This document defines how Kerfio can provide a standalone slicing workflow while using PrusaSlicer as the hidden slicing engine.

The user should feel that they are using Kerfio Slicer, not PrusaSlicer. PrusaSlicer should work in the background as a reliable slicing engine, called by the Kerfio backend through command-line execution.

The goal is:

Kerfio owns the user experience.
PrusaSlicer provides the mature slicing engine.
Kerfio manages profiles, jobs, preview, G-code, printer communication, and project history.

This gives Kerfio professional slicing capability without building a full slicer from zero.

#Core Product Decision

Kerfio 3D Printer section should have two major modes:

1. Printer Control Mode

   • Similar to Pronterface
   • Connect to printer
   • Move axes
   • Heat nozzle/bed
   • Extrude/retract
   • Send G-code
   • Start/pause/resume/stop print

2. Slicer Mode

   • Import 3D model
   • Choose printer profile
   • Choose material profile
   • Choose print quality
   • Slice model
   • Preview G-code
   • Send to printer

The slicing engine for the first professional version should be:

PrusaSlicer CLI / console engine

The user should not need to open PrusaSlicer manually.

#High-Level Architecture

Recommended architecture:

React / Tauri / Electron UI
        ↓
Kerfio Python Backend API
        ↓
Kerfio Slicing Service
        ↓
PrusaSlicer CLI Engine
        ↓
Generated G-code
        ↓
Kerfio G-code Analyzer + Preview
        ↓
Kerfio Printer Sender

#Main Components

#Frontend

Responsible for:

• Model import
• Build plate view
• Model transform controls
• Printer/material/quality settings
• Slice button
• Slice progress
• Layer preview
• G-code preview
• Send/export controls

#Python Backend

Responsible for:

• Receiving model files
• Validating models
• Managing slicing jobs
• Creating temporary slicing workspace
• Preparing PrusaSlicer config files
• Calling PrusaSlicer CLI
• Capturing stdout/stderr logs
• Reading generated G-code
• Extracting print statistics
• Saving job history
• Returning result to frontend

#PrusaSlicer Engine

Responsible for:

• Real slicing
• Mesh repair where supported
• Layer generation
• Wall/perimeter generation
• Infill generation
• Support generation
• G-code generation

#Kerfio G-code Layer

Responsible for:

• G-code validation
• Time estimation if needed
• Filament usage parsing
• Layer visualization
• Firmware compatibility checks
• Sending G-code to printer

#Important Principle: Standalone But Engine-Assisted

Kerfio should be standalone from the user's perspective.

This means:

• The user installs Kerfio.
• Kerfio includes or manages the slicer engine.
• The user does not need to learn PrusaSlicer.
• The user does not need to open PrusaSlicer.
• The user sees Kerfio printer profiles.
• The user sees Kerfio material profiles.
• Kerfio internally translates these settings into PrusaSlicer-compatible configuration.

However, internally:

• Kerfio can bundle PrusaSlicer binaries if license and distribution requirements are respected.
• Or Kerfio can detect an installed PrusaSlicer.
• Or Kerfio can allow the user to select the PrusaSlicer executable path.

#Deployment Options

#Option A — Bundled PrusaSlicer Engine

Kerfio installer includes PrusaSlicer CLI binaries.

#Advantages

• Best user experience
• No separate installation needed
• Version is controlled by Kerfio
• Easier support and debugging
• Reproducible slicing results

#Disadvantages

• Larger installer size
• Must follow PrusaSlicer license requirements
• Must manage platform-specific binaries

#Recommended For

Kerfio official production release.

#Option B — Detect Existing PrusaSlicer

Kerfio checks whether PrusaSlicer is installed.

#Advantages

• Smaller Kerfio installer
• Easier legal/distribution management
• User may already have PrusaSlicer installed

#Disadvantages

• Different versions on user machines
• Harder support
• Paths differ by OS
• Some users may not have it installed

#Recommended For

Early development version.

#Option C — User Selects Slicer Path

Kerfio asks the user to choose the PrusaSlicer executable manually.

#Advantages

• Simple to implement
• Flexible
• Useful for developer/testing versions

#Disadvantages

• Less professional UX
• More user confusion
• Path may break after updates

#Recommended For

Developer settings only, not primary UX.

#Recommended Strategy for Kerfio

Use a staged approach:

#Development Stage

Use user-installed PrusaSlicer or a manually configured path.

#Beta Stage

Add automatic detection and path validation.

#Production Stage

Bundle a tested PrusaSlicer CLI engine with Kerfio, if licensing/distribution review is acceptable.

#Operating System Executables

Kerfio must support Windows, macOS, and Linux.

#Windows

Use:

prusa-slicer-console.exe

Important: On Windows, the console executable is preferred for command-line usage because it properly exposes CLI output.

Possible locations:

C:\Program Files\Prusa3D\PrusaSlicer\prusa-slicer-console.exe
C:\Program Files\PrusaSlicer\prusa-slicer-console.exe

#macOS

Possible executable path inside application bundle:

/Applications/PrusaSlicer.app/Contents/MacOS/PrusaSlicer

If bundled inside Kerfio, store under:

Kerfio.app/Contents/Resources/slicers/prusaslicer/mac/PrusaSlicer

#Linux

Possible executable names:

prusa-slicer
PrusaSlicer

Possible locations:

/usr/bin/prusa-slicer
/usr/local/bin/prusa-slicer
/opt/PrusaSlicer/prusa-slicer

For AppImage usage, Kerfio may store a known AppImage and call it directly.

#Command-Line Usage Pattern

The basic command pattern is:

prusa-slicer-console.exe --export-gcode --load config.ini --output output.gcode model.stl

or conceptually:

PrusaSlicer --export-gcode --load <config-file> --output <output-file> <model-file>

Kerfio should not rely only on hardcoded commands forever. It should run:

PrusaSlicer --help

or:

prusa-slicer-console.exe --help

on startup or setup validation to confirm available CLI options for the bundled/detected version.

#Kerfio Slicing Job Lifecycle

#Job Creation

When the user clicks Slice, Kerfio creates a slicing job.

Example job object:

{
  "job_id": "slice_2026_00123",
  "status": "queued",
  "input_model": "part.stl",
  "printer_profile": "kerfio_ender3_0.4mm",
  "material_profile": "pla_generic",
  "print_profile": "0.20_quality",
  "output_format": "gcode",
  "created_at": "2026-05-30T12:00:00Z"
}

#Workspace Creation

For every slice job, create an isolated folder:

kerfio-data/
  slicing-jobs/
    slice_2026_00123/
      input/
      config/
      output/
      logs/
      preview/
      metadata/

Example:

slice_2026_00123/
  input/model.stl
  config/generated_config.ini
  output/model.gcode
  logs/prusaslicer_stdout.log
  logs/prusaslicer_stderr.log
  metadata/job.json
  metadata/result.json

#Input Validation

Before calling PrusaSlicer, Kerfio should validate:

• File exists
• File format is supported
• File size is reasonable
• Mesh loads successfully if possible
• Model bounding box is not larger than printer bed
• Model has non-zero dimensions
• Units are interpreted correctly
• Filename is safe
• No path traversal is possible

#Config Generation

Kerfio converts its own settings into PrusaSlicer .ini config.

#CLI Execution

Kerfio runs PrusaSlicer as a subprocess.

#Result Collection

After process completion, Kerfio checks:

• Exit code
• Output G-code exists
• G-code size > minimum expected size
• Logs do not contain fatal errors
• G-code has expected start/end structure

#Post-Processing

Kerfio may optionally:

• Parse G-code
• Count layers
• Estimate filament usage
• Estimate print time
• Generate layer preview
• Add metadata comments
• Normalize line endings
• Convert binary G-code to ASCII if needed
• Validate firmware flavor

#Final Result

Kerfio returns to frontend:

{
  "job_id": "slice_2026_00123",
  "status": "completed",
  "gcode_path": "output/model.gcode",
  "estimated_time_sec": 14320,
  "filament_used_mm": 5234,
  "filament_used_g": 15.8,
  "layer_count": 140,
  "warnings": []
}

#Kerfio Profile System

Kerfio should maintain its own profile database and generate PrusaSlicer configs from it.

Do not make Kerfio fully dependent on PrusaSlicer profile UI.

#Profile Types

Kerfio should have three profile categories:

Printer Profile
Material / Filament Profile
Print Quality Profile

These three combine into one PrusaSlicer config file for each slicing job.

#Printer Profile

Printer profile should include:

{
  "id": "ender3_v2_0_4_marlin",
  "name": "Creality Ender 3 V2 - 0.4mm - Marlin",
  "firmware": "marlin",
  "bed_size_x": 220,
  "bed_size_y": 220,
  "max_z": 250,
  "nozzle_diameter": 0.4,
  "filament_diameter": 1.75,
  "extruder_count": 1,
  "heated_bed": true,
  "start_gcode": "G28\nG92 E0",
  "end_gcode": "M104 S0\nM140 S0\nM84",
  "gcode_flavor": "marlin"
}

Required fields:

• Printer name
• Firmware type
• Bed size X/Y/Z
• Origin
• Nozzle diameter
• Filament diameter
• Extruder count
• Start G-code
• End G-code
• Max nozzle temperature
• Max bed temperature
• Connection profile

#Material Profile

Example:

{
  "id": "generic_pla_175",
  "name": "Generic PLA 1.75mm",
  "material": "PLA",
  "nozzle_temperature": 205,
  "bed_temperature": 60,
  "fan_speed": 100,
  "filament_diameter": 1.75,
  "filament_density": 1.24,
  "filament_cost_per_kg": 20,
  "retraction_distance": 0.8,
  "retraction_speed": 35
}

Required fields:

• Material type
• Nozzle temperature
• Bed temperature
• Fan speed
• Filament diameter
• Filament density
• Retraction settings
• Flow multiplier

#Print Quality Profile

Example:

{
  "id": "quality_020_standard",
  "name": "0.20mm Standard",
  "layer_height": 0.2,
  "first_layer_height": 0.24,
  "perimeters": 3,
  "top_solid_layers": 5,
  "bottom_solid_layers": 4,
  "infill_density": 20,
  "infill_pattern": "grid",
  "support_material": false,
  "brim_width": 0,
  "print_speed": 60,
  "travel_speed": 150
}

Required fields:

• Layer height
• First layer height
• Perimeters/walls
• Top/bottom layers
• Infill density
• Infill pattern
• Speed
• Supports
• Adhesion
• Cooling
• Retraction

#Mapping Kerfio Settings to PrusaSlicer INI

Kerfio should generate PrusaSlicer-compatible .ini files.

Example generated config:

# Generated by Kerfio
# Do not manually edit unless you know what you are doing

layer_height = 0.2
first_layer_height = 0.24
perimeters = 3
top_solid_layers = 5
bottom_solid_layers = 4
fill_density = 20%
fill_pattern = grid
support_material = 0
brim_width = 0
nozzle_diameter = 0.4
filament_diameter = 1.75
temperature = 205
bed_temperature = 60
first_layer_temperature = 210
first_layer_bed_temperature = 60
retract_length = 0.8
retract_speed = 35
gcode_flavor = marlin

Important: The exact keys should be tested against the target PrusaSlicer version using exported profiles and --help output.

#Better Profile Strategy: Template Configs

The safest strategy is not to manually invent every PrusaSlicer .ini key.

Recommended approach:

1. Create tested base profiles in PrusaSlicer.
2. Export them as .ini config files.
3. Store them in Kerfio as templates.
4. Kerfio modifies only selected safe values.
5. Kerfio passes the generated .ini to PrusaSlicer.

Example folder:

kerfio-resources/
  slicer-profiles/
    prusaslicer/
      printers/
        ender3_v2_marlin.ini
        voron_24_klipper.ini
        prusa_mk3s.ini
      materials/
        generic_pla.ini
        generic_petg.ini
        generic_abs.ini
      quality/
        020_standard.ini
        016_quality.ini
        028_draft.ini

Then Kerfio merges selected profiles into:

slice_job/config/generated_config.ini

#Profile Merge Logic

Recommended merge order:

Base Printer Config
    ↓
Material Config
    ↓
Print Quality Config
    ↓
User Overrides
    ↓
Job-Specific Transform Settings

Example:

ender3_v2_marlin.ini
+ generic_pla.ini
+ 020_standard.ini
+ user_changed_infill_35_percent
= generated_config.ini

If the same key exists in multiple files, later layers override earlier layers.

#Model Transform Handling

Kerfio frontend should allow:

• Move model
• Rotate model
• Scale model
• Duplicate model
• Arrange models
• Center on bed
• Lay flat

There are two possible ways to apply transforms.

#Apply Transform Before Slicing

Kerfio modifies or exports a transformed model file before sending it to PrusaSlicer.

Advantages:

• Predictable
• Backend controls geometry
• Easier to preview accurately

Disadvantages:

• Requires mesh processing in Kerfio

Recommended backend libraries:

• trimesh
• numpy
• meshio

#Pass Transform Options to PrusaSlicer CLI

PrusaSlicer/Slic3r CLI supports transform options such as scale, rotate, center, duplicate, merge, etc.

Advantages:

• Less mesh processing in Kerfio

Disadvantages:

• Requires careful version testing
• Harder to keep UI preview and final slice perfectly synchronized

Recommended first version:

Apply transforms in Kerfio and export a prepared STL/3MF to the slicing workspace.

#Input Model Formats

Kerfio 3D Printer Slicer should accept:

• .stl
• .obj
• .3mf
• .amf optional

Recommended first version:

• STL
• OBJ
• 3MF

For CAD section transfer:

Kerfio CAD model → mesh export → STL/3MF → Kerfio Slicer → G-code

#Output Formats

Primary output:

• .gcode ASCII G-code

Optional later:

• .bgcode binary G-code
• .3mf sliced project archive if supported

Recommendation:

For Kerfio v1, use normal ASCII .gcode by default.

Reason:

• Easier to preview
• Easier to debug
• Easier to send over serial
• Easier to parse
• Better compatibility with generic printers and OctoPrint-like systems

Binary G-code can be added later only for compatible printers.

#Binary G-code Warning

PrusaSlicer supports binary G-code for some newer Prusa workflows.

Kerfio must be careful with this.

For general printer compatibility, Kerfio should disable binary G-code by default and prefer ASCII .gcode.

Why:

• Many generic printers expect ASCII G-code
• Serial senders expect ASCII commands
• Some external print hosts may not handle binary G-code
• Kerfio preview/parser will be easier with ASCII G-code

Kerfio can later add:

Enable binary G-code when printer profile supports it

But the default should remain ASCII G-code.

#Python Backend Implementation

#Suggested API Endpoints

POST /api/slicer/jobs
GET  /api/slicer/jobs/{job_id}
GET  /api/slicer/jobs/{job_id}/logs
GET  /api/slicer/jobs/{job_id}/gcode
POST /api/slicer/jobs/{job_id}/cancel
POST /api/slicer/validate-engine
GET  /api/slicer/profiles/printers
GET  /api/slicer/profiles/materials
GET  /api/slicer/profiles/quality

#Example Slice Request

{
  "model_file_id": "file_123",
  "printer_profile_id": "ender3_v2_0_4_marlin",
  "material_profile_id": "generic_pla_175",
  "quality_profile_id": "quality_020_standard",
  "overrides": {
    "infill_density": 25,
    "support_material": true,
    "brim_width": 4
  },
  "output_format": "gcode"
}

#Example Slice Response

{
  "job_id": "slice_2026_00123",
  "status": "queued"
}

#Example Result Response

{
  "job_id": "slice_2026_00123",
  "status": "completed",
  "progress": 100,
  "output": {
    "gcode_file_id": "gcode_456",
    "filename": "model_0.20mm_PLA.gcode",
    "size_bytes": 2489231
  },
  "stats": {
    "estimated_time_sec": 14320,
    "filament_mm": 5234,
    "filament_g": 15.8,
    "layer_count": 140
  },
  "warnings": []
}

#Python Subprocess Execution Example

Example implementation concept:

import subprocess
from pathlib import Path


def run_prusaslicer_slice(
    slicer_exe: Path,
    model_path: Path,
    config_path: Path,
    output_path: Path,
    timeout_seconds: int = 1800,
):
    cmd = [
        str(slicer_exe),
        "--export-gcode",
        "--load", str(config_path),
        "--output", str(output_path),
        str(model_path),
    ]

    result = subprocess.run(
        cmd,
        cwd=str(output_path.parent),
        capture_output=True,
        text=True,
        timeout=timeout_seconds,
    )

    return {
        "returncode": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr,
        "output_exists": output_path.exists(),
        "output_size": output_path.stat().st_size if output_path.exists() else 0,
    }

Important production requirements:

• Never pass unsanitized user strings directly to shell.
• Use subprocess.run([...]), not shell=True.
• Use isolated job folders.
• Enforce timeout.
• Capture logs.
• Check output file existence.

#Engine Validation

Kerfio should validate PrusaSlicer before enabling slicing.

Validation steps:

1. Check executable exists.
2. Run version command or help command.
3. Confirm process exits successfully.
4. Confirm CLI output is readable.
5. Confirm a tiny test STL can be sliced.
6. Confirm generated G-code exists.
7. Save validation result.

Example validation result:

{
  "engine": "prusaslicer",
  "valid": true,
  "path": "C:/Program Files/Prusa3D/PrusaSlicer/prusa-slicer-console.exe",
  "version": "2.x",
  "supports_cli": true,
  "last_checked": "2026-05-30T12:00:00Z"
}

#Frontend UX Design

#Main Slicer Screen

Recommended layout:

┌──────────────────────────────────────────────────────────────┐
│ Kerfio 3D Printer / Slicer                                   │
├───────────────┬──────────────────────────────┬───────────────┤
│ Model List    │ 3D Build Plate Preview        │ Settings      │
│               │                              │ Printer       │
│ part.stl      │                              │ Material      │
│               │                              │ Quality       │
│               │                              │ Supports      │
│               │                              │ Infill        │
├───────────────┴──────────────────────────────┴───────────────┤
│ Slice | Preview G-code | Export | Send to Printer             │
└──────────────────────────────────────────────────────────────┘

#Basic User Controls

The simple mode should show:

• Printer
• Material
• Quality
• Layer height
• Infill
• Supports
• Adhesion
• Slice button

#Advanced Controls

Advanced mode should show:

• Perimeters
• Top/bottom layers
• Speed settings
• Retraction
• Cooling
• Support details
• Start/end G-code
• Filament properties
• Custom G-code

#G-code Preview

After slicing, Kerfio should show:

• Layer slider
• Toolpath lines
• Perimeters
• Infill
• Supports
• Travel moves
• Retractions
• Estimated print time
• Filament usage
• G-code file size

Recommended frontend rendering:

• Three.js for 3D G-code preview
• WebGL line rendering
• Worker thread for parsing large G-code

Recommended parser behavior:

• Parse G0/G1 moves
• Track X/Y/Z/E/F
• Detect layer changes
• Detect extrusion moves
• Detect travel moves
• Detect retraction moves
• Estimate bounding box

#Connection to Printer Control

After slicing, user should be able to:

• Export G-code
• Save Kerfio print job
• Send to printer
• Open in printer control panel
• Queue print job

Printer sender must support:

• Serial USB printing
• Baud rate selection
• Console log
• Temperature monitoring
• Pause/resume/stop
• Emergency stop

#Integration with Kerfio CAD

Kerfio CAD should send 3D models directly to the slicer.

Workflow:

Kerfio CAD
  → Export mesh internally as STL or 3MF
  → Open Kerfio Slicer
  → Place model on bed
  → Slice with PrusaSlicer engine
  → Preview G-code
  → Print

Recommended user command:

Send to 3D Printer

The user should not manually export/import unless they want to.

#Project File Integration

Kerfio project file should preserve slicing information.

Example .kerfio-print structure:

my_part.kerfio-print
  /project.json
  /models/original.stl
  /models/prepared.stl
  /profiles/printer.json
  /profiles/material.json
  /profiles/quality.json
  /slicer/generated_config.ini
  /gcode/output.gcode
  /logs/slice.log
  /preview/thumbnail.png

The project should store:

• Model reference
• Model transform
• Printer profile
• Material profile
• Print profile
• User overrides
• Slicer engine version
• Generated G-code hash
• Slice date/time
• Warnings

#Job Status Model

Recommended statuses:

queued
preparing
validating
slicing
post_processing
completed
failed
cancelled

Example:

{
  "job_id": "slice_2026_00123",
  "status": "slicing",
  "progress": 45,
  "message": "Generating infill and support paths..."
}

Note: PrusaSlicer CLI may not always provide detailed progress in a clean machine-readable way. Kerfio can show coarse progress stages first.

#Error Handling

Kerfio should convert raw PrusaSlicer errors into user-friendly messages.

#Common Error Types

• Slicer engine not found
• Invalid model file
• Model too large for bed
• Configuration error
• Unsupported profile combination
• Timeout
• No G-code generated
• Permission problem
• Disk space problem
• Unsupported output format

#Example Error Response

{
  "job_id": "slice_2026_00123",
  "status": "failed",
  "error_code": "SLICER_CONFIG_ERROR",
  "user_message": "The selected printer and material profiles are not compatible.",
  "technical_log_path": "logs/prusaslicer_stderr.log"
}

#Security Considerations

Important security rules:

• Never use shell=True for slicing commands.
• Sanitize all filenames.
• Use job-specific temporary folders.
• Prevent path traversal.
• Restrict input file extensions.
• Enforce file size limits.
• Enforce slicing timeout.
• Store logs safely.
• Do not allow arbitrary user command-line arguments in normal UI.
• Advanced custom G-code should be clearly marked as advanced and risky.

#Performance Considerations

Slicing can be CPU-heavy.

Kerfio should:

• Run slicing in a background worker process
• Keep UI responsive
• Allow cancel job
• Limit concurrent slicing jobs in desktop version
• Cache generated results when settings do not change
• Show logs/progress
• Clean old temporary files

Recommended first version:

One active slicing job at a time
Queue additional jobs

#Licensing and Distribution Note

PrusaSlicer is open-source, but Kerfio must respect its license and third-party dependency licenses.

Before bundling PrusaSlicer binaries in the Kerfio installer, the team should:

• Review PrusaSlicer license
• Review dependency licenses
• Include required notices
• Provide source/license references where required
• Avoid implying that Prusa Research officially endorses Kerfio unless there is permission
• Keep Kerfio branding separate from PrusaSlicer branding

Recommended wording inside Kerfio settings:

Kerfio Slicer uses an integrated open-source slicing engine based on PrusaSlicer.

Only use exact naming after legal review.

#Recommended Folder Structure

kerfio/
  backend/
    app/
      slicer/
        slicer_service.py
        prusaslicer_engine.py
        profile_manager.py
        config_generator.py
        gcode_analyzer.py
        job_manager.py
      printers/
        printer_sender.py
        serial_connection.py
  frontend/
    src/
      modules/
        printer3d/
          SlicerPage.tsx
          BuildPlate3D.tsx
          SliceSettingsPanel.tsx
          GcodePreview.tsx
          PrinterControlPanel.tsx
  resources/
    slicers/
      prusaslicer/
        windows/
        macos/
        linux/
    profiles/
      printers/
      materials/
      quality/
  data/
    slicing-jobs/
    projects/
    logs/

#Recommended MVP Feature Set

MVP means Minimum Viable Product.

#MVP Slicer Features

• Import STL
• Import OBJ
• Import 3MF
• Select printer profile
• Select material profile
• Select quality profile
• Set layer height
• Set infill percentage
• Enable/disable supports
• Enable brim/skirt
• Slice using PrusaSlicer CLI
• Generate ASCII G-code
• Show basic result statistics
• Export G-code
• Send G-code to printer control panel

#MVP Printer Profiles

Start with:

• Generic Marlin 220 × 220 × 250 mm printer
• Creality Ender 3 style profile
• Generic CoreXY Klipper profile
• Custom printer profile wizard

#MVP Materials

Start with:

• Generic PLA
• Generic PETG
• Generic ABS
• Generic TPU

#MVP Quality Profiles

Start with:

• 0.28 mm Draft
• 0.20 mm Standard
• 0.16 mm Quality
• 0.12 mm Fine

#Future Features

After MVP:

• Multi-object arrangement
• Auto-arrange on build plate
• Multiple plates
• Advanced supports
• Tree supports if supported
• Variable layer height
• Color/material change
• Multi-extruder support
• Thumbnails
• Klipper-specific macros
• OctoPrint/Moonraker upload
• Print time calibration
• Filament cost calculation
• AI setting recommendation
• Failure-risk detection
• Mesh repair UI
• Model hollowing for special workflows

#Development Roadmap

#Phase 1 — Engine Integration

• Add slicer engine path setting
• Validate PrusaSlicer CLI
• Run test slice
• Save logs
• Return G-code

#Phase 2 — Kerfio Profiles

• Create printer/material/quality profile system
• Generate .ini config
• Merge templates
• Save profile database

#Phase 3 — UI Slicer Page

• 3D build plate preview
• Import model
• Transform model
• Select profiles
• Slice button
• Result panel

#Phase 4 — G-code Preview

• Parse G-code
• Layer slider
• Toolpath view
• Estimated values

#Phase 5 — Printer Sender Integration

• Send sliced G-code to printer control
• Print monitoring
• Pause/resume/stop

#Phase 6 — Standalone Production Packaging

• Bundle slicer engine
• Include license notices
• Add engine update mechanism
• Support Windows/macOS/Linux builds

#Final Recommendation

For Kerfio, the best professional strategy is:

Build Kerfio Slicer as a standalone Kerfio module.
Use PrusaSlicer as the hidden engine.
Control everything through Kerfio UI, Kerfio profiles, Kerfio job system, and Kerfio printer sender.

Do not expose PrusaSlicer as an external application in the normal workflow.

The user should only see:

Import Model → Choose Printer → Choose Material → Choose Quality → Slice → Preview → Print

Internally, Kerfio should execute:

PrusaSlicer CLI → Generate G-code → Kerfio Preview/Sender

This gives Kerfio a real professional slicer workflow while keeping development realistic and maintainable.