3D PRINTING SOFTWARE ENGINEER

Meet your instructor, walk through the full course structure, and get your development environment set up before diving into the industrial software stack.

• Course structure and expectations
• Assignments and final project overview
• Software setup

Break down the three primary 3D printing modalities, FDM, SLA/DLP, and powder bed fusion, from a software architecture perspective, then trace the deconstructed slicing pipeline from B-Rep to G-code.

• B-Rep vs. tessellated mesh formats
• Tessellation and topology parsing
• Planar projection and vector transformations
• G-code compilation
• Demo: Tracing a print job through the OctoPrint/Klipper ecosystem

Learn the anatomy of modal and non-modal G-code commands, fast string parsing with regular expressions, and how absolute versus relative distance modes affect extrusion accuracy.

• Modal vs. non-modal commands
• Regex-based string parsing
• Extrusion calculation modes
• Non-planar toolpath interpolation
• Workshop: Writing a Python state-machine script to inject custom cooling fan speeds

Master the printer's 4D kinematic vector space, calculate Euclidean distances for volumetric flow rates, and convert commanded feedrates into stepper motor pulse timing.

• 4D kinematic vector space
• Euclidean distance calculations
• Feedrate-to-pulse conversion
• Case study: How Input Shaping cancels mechanical resonance with math

Explore the mathematical foundations of polygon clipping and offsetting, generate infill patterns like grid, honeycomb, and gyroid, and visualize path planning through Minkowski sums.

• Polygon clipping and offsetting
• Winding number algorithm
• Infill pattern generation
• Demo: Visualizing the Minkowski sum for path planning

Tune PID loops for thermistors, time stepper driver pulses precisely, and simulate thermal runaway protection in C++ to keep industrial hardware running safely under load.

• PID loop tuning
• Stepper driver pulse timing
• Workshop: Simulating thermal runaway protection in C++

Diagnose the industrial bottlenecks worth solving using Big-O complexity analysis, then blueprint the architecture and data models for your final capstone project.

• Industrial bottleneck diagnosis
• Big-O complexity analysis
• Architecture blueprinting

Assignment #1: The Parser
Build a Python or C++ tool that predicts material waste and print time from a G-code file with over 95% accuracy against a real physical run.

Implement half-edge data structures for dynamic mesh manipulation, break past brute-force geometric lookups with BVH and octree acceleration, and detect broken topology at industrial scale.

• Half-edge data structures
• BVH and octree acceleration
• Non-manifold edge detection
• Point-in-polygon classification
• Workshop: Building a mesh diagnostic kernel to test for watertight geometry

Generate support structures with overhang angle calculations, solve the traveling salesman problem to shorten print paths, and control stringing with smart retraction routes.

• Support structure generation
• Traveling salesman path optimization
• Stringing and retraction control
• Case study: ArcWelder, converting linear moves into G2/G3 curves

Assignment #2: The Optimizer
Implement a "smooth-motion" script that reduces jerk by recalculating acceleration curves.

Parallelize slicing across CPU threads, port geometric computation to the GPU, and manage high-speed memory transfer between host and device architectures used to process massive industrial datasets.

• CPU multi-threading strategies
• GPU thread hierarchies and grids
• Host-to-device memory management

Assignment #3: CUDA Kernel
Write a Numba-based CUDA kernel that parallelizes 2D boundary polygon intersection tests across millions of mesh triangles at once.

Voxelize 3D meshes into high-resolution volumetric grids on the GPU, then use signed distance fields to hollow, shell, and blend geometry without triangle clipping.

• GPU voxelization
• Signed distance field math
• Implicit boolean geometry operations
• Workshop: Writing a parallel 3D SDF solver with Python and Numba CUDA

Build a computer vision pipeline with OpenCV that catches print anomalies, verifies part presence, and analyzes surface quality in real time.

• Classical vs. deep learning approaches
• Temporal anomaly detection
• Geometric verification and surface analysis

Assignment #4: Part Detection
Write a script that detects whether a part is present on the print bed and calculates its surface area.

Design command-line tools for slicers and build secure cloud-to-local bridges that keep industrial print data protected as manufacturers move toward connected, cloud-driven production.

• CLI tool design
• Cloud-to-local bridge security

Develop your minimum viable product and implement the core algorithm behind your chosen final project track, whether that's a smart slicer plugin or a custom infill generator.

• MVP development
• Core algorithm implementation

Assignment #5: The Alpha Release
Submit the core logic of your chosen project track, such as the Smart Slicer or Infill Generator.

Write unit tests for geometry code, profile your program for performance bottlenecks, and practice peer code review focused on clean code principles.

• Unit testing for geometry
• Performance profiling
• Workshop: Peer-to-peer code review on clean code principles

Learn to handle illegal geometry inputs and recover gracefully from lost serial connections before your software ever reaches production.

• Illegal geometry handling
• Serial connection recovery

Assignment #6: The Stress Test
Report on how your software handles a corrupted input or an extreme hardware constraint.

Compare CLI and GUI design approaches for shop-floor operators and apply HMI design concepts built for industrial environments.

• CLI vs. GUI design
• HMI design concepts

Write technical specs, choose between GPL and MIT licensing, and package your software in Docker, with insight from a guest application engineer in the AM space.

• Technical spec writing
• GPL vs. MIT licensing
• Dockerizing your tool
• Guest speaker: Application engineer in the additive manufacturing space

Assignment #7: The Industrial Portfolio
Submit your final GitHub repository with full source code, documentation, and a recorded demo video.

Map the modern AM landscape across aerospace, medical, and automotive, explore the shift toward implicit computing and born-qualified parts, and demo your final capstone project.

• Aerospace, medical, and automotive AM roles
• Implicit computing and born-qualified parts
• AM career paths and technical interviews
• Capstone: Final project demonstration and GitHub repo submission