Pith. sign in

REVIEW 4 major objections 5 minor 125 references

Formalizing Linear Motion G-code for Invariant Checking and Differential Testing of Fabrication Tools

T0 review · 4 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read By denoting linear-motion G-code as cuboids and comparing approximate point clouds, this paper catches slicing failures before printing and differentially tests slicers and mesh repair tools.

desk verdict Novel G-code-to-cuboid lifting with a practical comparison algorithm, but the error-localization claim is only qualitatively supported at present. read the letter →

arxiv 2509.00699 v1 pith:IXGWYDYE submitted 2025-08-31 cs.PL

Yumeng He , Chandrakana Nandi , Sreepathi Pai This is my paper
classification cs.PL
keywords G-codedenotationalsemanticspointcloudcomparisonHausdorffdistanceinvariantcheckingdifferentialtesting3Dprintingslicersmeshrepair
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper's claim is that the machine code of 3D printing—G-code—can be treated like low-level program code and analyzed formally. It defines a denotational semantics for linear-motion G-code that reconstructs each extruded line as a cuboid, then samples the cuboids into a point cloud and compares two such clouds with a box-wise augmented Hausdorff distance. On top of this, it checks a rotation invariant: slicing a model, rotating it, and slicing again should produce G-code whose point clouds agree. The paper reports that on 50 real-world models known to slice badly, this invariant check localized the reported problem regions in all 50 cases, and the same comparison kernel separates how Cura and PrusaSlicer behave and whether MeshLab and Meshmixer repairs help or hurt. A reader should care because these failures are invisible at the CAD or mesh level and currently surface only after expensive failed prints.

What carries the argument

The load-bearing object is the cuboid denotation of a G-code program: each G1 move from point A to B with nozzle diameter d and layer height h becomes a rectangular box of dimensions (length+d) × d × h, replacing the true rounded-end extruded line. From the cuboid set, a proportional sampler (sampling gap g) generates an approximate point cloud. Comparison runs through a segmented, augmented Hausdorff distance: the union bounding box is divided into unit boxes; within each box the Hausdorff distance is computed not just against the other box's points but against the 27-box neighborhood, which absorbs points displaced across box boundaries by floating-point error. The paper's rotation invaria

What would settle it

Slice a defect-free prism, rotate the mesh 90 degrees, slice again, and compare the two point clouds: if the augmented Hausdorff distance is nonzero and persists as the sampling gap shrinks, the method reports a difference where none exists. Alternatively, physically print a model in a region that GlitchFinder flags and in a region it does not: a flagged region that prints perfectly while an unflagged region fails would falsify the localization claim.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that G-code programs can be lifted to a geometry—cuboids, then an approximate point cloud—and that every analysis task considered reduces to comparing two such point clouds. The semantics, gcode^h_d, parameterized by layer height h and nozzle diameter d, maps each G1 extrusion to a rectangular cuboid of length line length plus nozzle diameter, breadth nozzle diameter, and height layer height. A proportional sampler Ω_g turns the cuboid set into a point cloud, and an augmented Hausdorff distance computed per unit box, with a 27-box neighborhood absorbing floating-point misclassification, turns point clouds into a localized difference heatmap.

Load-bearing premise

The load-bearing premise is that treating each extruded line as a rectangular box of height equal to layer height, and treating point-cloud differences at the chosen sampling gap and unit-box scale as fabrication-relevant differences, is faithful enough; the paper supports this with per-model parameter tuning and qualitative inspection, not a calibrated error analysis.

Editorial extensions

If this is right

  • A print can be checked before printing: the rotation invariant turns "will this model slice correctly?" into a static comparison, and the paper reports it found the reported problem region in all 50 broken benchmarks.
  • Small-feature failures, invisible to mesh-repair tools because feature smallness is relative to nozzle and slicer settings, become visible because the analysis operates on G-code.
  • Slicers can be differentially tested on the same models: the paper found Cura and PrusaSlicer produced materially different G-code on 40 of 52 models, with neither dominating across defect types.
  • Mesh repair tools can be scored by outcome: repair is only successful if the repaired mesh's G-code matches the intent of the original; the paper found both MeshLab and Meshmixer frequently left slicing errors and sometimes added new ones.
  • Because comparison is between G-code programs, the same kernel can be reused to check translations and scalings, compare slicer settings, and monitor tooling quality in CI pipelines.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The point-cloud lifting could be generalized to other affine invariants beyond rotation—translation, scaling, mirroring—and to comparisons between different printer profiles or slicer settings, not just different tools; the paper notes translation and scaling commute with denotation but does not evaluate them.
  • Sampling gap and unit-box size act as a sensitivity dial: choosing them relative to the nozzle diameter should let the method detect features at any target size, suggesting a calibration procedure could replace per-model manual tuning.
  • Because the cuboid model ignores the rounded ends of extruded lines, the method is inherently approximate; an extension that models the capsule-shaped cross-section would likely reduce the spatial averaging needed to suppress quantization noise.
  • A natural next test is to use flagged heatmap regions as input to automatic mesh repair or parameter adjustment, closing the loop between diagnosis and fix; the paper stops at diagnosis.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes GlitchFinder, a tool for analyzing linear-motion G-code by lifting each extruded move to an axis-aligned cuboid, sampling the cuboid set into an approximate point cloud, segmenting the cloud into unit boxes, and comparing two clouds with an augmented Hausdorff distance. It uses this machinery to check a rotation invariant of G-code (slicing a mesh in different orientations should produce point clouds that agree up to rotation), to differentially test two slicers (Cura and PrusaSlicer), and to evaluate two mesh repair tools (MeshLab and Meshmixer). The evaluation covers 58 real-world models, including 50 reportedly problematic models drawn from slicer issue trackers and 6 error-free models. The paper claims that all 50 problematic benchmarks were correctly localized, that slicer differences are revealed quantitatively, and that the tool can identify cases where mesh repair introduces new defects.

Significance. If the localization claims are established, this is a useful contribution: it brings compiler-style invariant checking and differential testing to the fabrication pipeline at the G-code level, where failures that are invisible in CAD or mesh representations become observable. The cuboid/point-cloud lifting is a sensible practical approximation, and the paper ships a public artifact, benchmark collection, and automation scripts. The formal big-step semantics for the linear-motion subset is a clear starting point for future work. The main weakness is validation: the central effectiveness claims currently rest on per-model parameter selection, visual inspection of heatmaps, and qualitative distribution-shape judgments rather than on quantitative agreement with known problem locations.

major comments (4)
  1. [§7.2, §7.3, §11 (Tables 8-9)] The claim in §7.3 that 'In all 50 problematic benchmarks, GlitchFinder successfully identified the problematic areas' is not supported by a quantitative accuracy measurement. The 50 models were selected from GitHub issues/forums where the problem locations were already reported, so ground truth is available in principle, yet no precision/recall, IoU, or similar overlap metric is reported between highlighted unit boxes and known defective regions. The situation is aggravated by the parameter choices: §11 states that sampling gap, unit box size, and threshold are 'the values that we found worked best for each model,' i.e., selected post hoc per benchmark, and the threshold percentile in §5.2 colors the top 10% of distances by construction. To substantiate the central claim, the paper should compare highlighted boxes against ground-truth regions, report aggregate overlap statistics, and pro
  2. [§5.3, §7.3.4] The distinction between true differences and unwanted errors relies on the shape of the distance distribution: true differences are said to produce right-skewed distributions, while error-free models produce 'approximately normal or slightly left-skewed' ones. No quantitative criterion is given for this classification, and the error-free examples are judged by eye. Since the heatmaps alone are conceded (in §7.3.4) to be insufficient, the distribution graph is load-bearing for the false-positive story; however, there is no reported measure (e.g., skewness, excess-kurtosis, or a separation score) and no evaluation of how well such a measure separates the 50 problematic models from the 6 error-free models. Please make this discriminator explicit and validate it, or temper the false-positive claims.
  3. [§8.1.2, §8.2.2] The differential-testing and mesh-repair conclusions are similarly validated only by manual visual comparison of G-code renders and heatmaps. Terms such as 'better', 'complete resolution', 'partial improvement', and 'new slicing defects' are not tied to an operational, repeatable criterion. For example, Table 3 reports that MeshLab leaves 29/37 models 'Not fixed'; but whether two G-code programs denote the same defective region is determined qualitatively. Since the paper proposes differential testing as a general methodology, the evaluation should provide a reproducible way to classify outcomes, ideally with inter-rater agreement or a rule based on the augmented-Hausdorff output itself (e.g., overlap with known problem regions, as in the invariant-checking application).
  4. [§3.1, Figure 6] The G1 rule adds a cuboid for every G1 command regardless of the E attribute, because attributes are said not to affect semantics. Real slicer G-code contains G1 moves that do not extrude, including retraction moves and moves that only change Z. In the illustrative snippet in §2, for instance, 'G1 F 600 Z 2.3' follows a negative E move. Under the current semantics, such commands would contribute phantom cuboids to the reconstructed solid, which could bias both the rotation-invariant check and the slicer comparisons if the two compared programs contain different non-extruding moves. The paper should either refine the semantics to condition cuboid creation on E (or on a defined notion of extrusion), or explicitly state and justify the assumption that all G1 commands in the analyzed benchmarks are extrusion moves.
minor comments (5)
  1. [Abstract / §7 / §8] The paper states it evaluates on 58 models in the abstract, but §7 says 56 benchmarks for invariant checking and §8.1.1 says 52 models for slicer comparison. Please clarify the relationship between these counts (e.g., 56 + 2 exclusive slicer models = 58).
  2. [§11, Tables 8-9] The caption says these tables list the parameters for all benchmarks, but threshold percentile and rotation angles—both described as user-configurable in §7.2—are not reported per model. Including them would make the experiments reproducible and would also expose how much the results depend on the chosen threshold.
  3. [§5.1] The spatial-averaging step averages distances over neighboring boxes but the description of how 'none' and 'infinity' values interact with averaging is informal. Algorithm 1 returns hd_list; the exact averaging formula and the treatment of ∞ distances during averaging should be specified in pseudocode or equations.
  4. [§7.3.1] For Amy and Warrior, the paper says Cura failed to slice the original orientation, so a 90-degree z-rotation was treated as the original for those models. This changes the benchmark setup; please state explicitly which models needed this workaround, since it affects the interpretation of the rotation-invariant results.
  5. [§8.1] Section 7 uses Cura on Linux with specific settings, while §8.1.1 says the slicer comparison was run on MacOS M1 with Cura 5.3.1. Please state whether the same Cura version and settings were used in both experiments; otherwise differences between sections could be attributed to version or platform.

Circularity Check

1 steps flagged · score 5.0 of 10

Core G-code lifting and differential comparison are self-contained, but the headline claim of successful problem localization is partly circular because detection parameters (sampling gap, unit box size, rotation axes, threshold percentile) were chosen per benchmark after inspecting outputs, and the visualization highlights the top decile by construction.

  1. fitted input called prediction [Section 7.3, Section 7.2, Section 11 / Table 8-9]
    "“In all 50 problematic benchmarks, GlitchFinder successfully identified the problematic areas.” ... “The right value will obtain the “right” number of errors – a number which does not overwhelm the user but still provides “actionable” information ... We list the values that we found worked best for each model.”"

    The success claim is not an independent prediction: the sampling gap, unit box dimensions, rotation axes, and threshold percentile are user-configurable and were selected per benchmark ('we list the values that we found worked best for each model') after inspecting the benchmark models. With a 90th-percentile threshold, some unit boxes are colored as extreme by construction, and adjusting box size can move a target feature into that top decile. Thus 'GlitchFinder successfully identified the problematic areas' is partly a restatement of the fitting procedure rather than a validated detection result. The underlying G-code-to-point-cloud comparison itself is not circular; only the evaluation of the central localization claim is.

full rationale

The paper's technical derivation—lifting G-code to cuboids via the operational semantics in Section 3.1, approximating cuboids by point clouds, and comparing point clouds with the augmented Hausdorff metric—is self-contained and does not reduce to its inputs. There is no load-bearing self-citation chain, no imported 'uniqueness theorem,' and no ansatz smuggled in via citation. The differential-testing applications (slicer comparison and mesh-repair evaluation) are externally grounded by visual G-code inspection and do not themselves exhibit circularity. The main circularity concern is confined to the invariant-checking evaluation: the claim that all 50 problematic models were successfully localized is supported only by per-model parameter tuning (sampling gap, unit box size, rotation angles, threshold percentile) and visual inspection of heatmaps, without a quantitative overlap metric against the known defective regions. Because the threshold percentile forces the top decile of distances to appear highlighted by construction, and because parameter values were chosen post hoc per model to 'work best,' the reported success is partly an artifact of the fitting procedure. This warrants a moderate circularity score, but not a high one, since the core analysis technique has independent content and the paper itself concedes that heatmaps alone cannot distinguish true differences from unwanted errors.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The central claim rests on the modeling assumption that G-code can be lifted to cuboids and sampled point clouds, plus the validity of rotation invariance as an error signal. These are introduced by the paper rather than established independently, and the evaluation depends on per-model parameter choices.

free parameters (5)
  • Sampling gap g = varies per model (e.g., 0.01 to 3.0 mm, Tables 8-9)
    Controls point cloud density; chosen per model to balance speed and sensitivity, explicitly tuned to produce useful heatmaps.
  • Unit box size = varies per model (e.g., 0.05 to 5.0 mm, Tables 8-9)
    Used for segmenting point clouds; the paper states that the right value obtains the right number of errors and that values were chosen that worked best for each model.
  • Threshold percentile = 90th percentile in the paper's examples
    User-set cutoff for distinguishing true differences from unwanted errors; tuning this changes the heatmap classification.
  • Rotation axes/angles = (90,0,0) and (0,90,0)
    Chosen after observing that 45-degree rotations increase unwanted errors; the choice affects which errors are exposed.
  • Cuboid geometry approximation = rectangle of length l+d, breadth d, height h, ignoring rounded corners
    Modeling assumption about extruded filament shape; not fitted to data but a free modeling choice that affects all results.
assumptions (4)
  • domain assumption Uniform planar slicing with constant layer height
    The cuboid reconstruction assumes G-code generated by uniform planar slicing (Section 2); other slicing strategies are not modeled.
  • ad hoc to paper Extruded filament can be represented as a rectangular cuboid
    Figure 5 approximates a deposited line as a box, ignoring rounded ends and variable extrusion width; this is a deliberate simplification.
  • domain assumption Rotation invariance is a valid error signal
    The invariant I (Section 7) assumes that rotating a model before slicing should not change the printed shape, but this can fail for legitimate orientation-dependent designs (overhangs); the paper acknowledges this but still uses the invariant.
  • standard math Standard geometry and Hausdorff distance properties
    Used in the cuboid vertex calculation (Section 3.1) and point cloud comparison (Section 4).

how reviews work

0 comments
Cite this review

Pith. "Pith review of Formalizing Linear Motion G-code for Invariant Checking and Differential Testing of Fabrication Tools." pith.science (2026). https://pith.science/paper/IXGWYDYE

@misc{pith2026250900699,
  author       = {Pith},
  title        = {Pith review of: Formalizing Linear Motion G-code for Invariant Checking and Differential Testing of Fabrication Tools},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IXGWYDYE}},
  note         = {Machine review of arXiv:2509.00699}
}
read the original abstract

The computational fabrication pipeline for 3D printing is much like a compiler - users design models in Computer Aided Design (CAD) tools that are lowered to polygon meshes to be ultimately compiled to machine code by 3D slicers. For traditional compilers and programming languages, techniques for checking program invariants are well-established. Similarly, methods like differential testing are often used to uncover bugs in compilers themselves, which makes them more reliable. The fabrication pipeline would benefit from similar techniques but traditional approaches do not directly apply to the representations used in this domain. Unlike traditional programs, 3D models exist both as geometric objects as well as machine code that ultimately runs on the hardware. The machine code, like in traditional compiling, is affected by many factors like the model, the slicer being used, and numerous user-configurable parameters that control the slicing process. In this work, we propose a new algorithm for lifting G-code (a common language used in fabrication pipelines) by denoting a G-code program to a set of cuboids, and then defining an approximate point cloud representation for efficiently operating on these cuboids. Our algorithm opens up new opportunities: we show three use cases that demonstrate how it enables error localization in CAD models through invariant checking, quantitative comparisons between slicers, and evaluating the efficacy of mesh repair tools. We present a prototype implementation of our algorithm in a tool, GlitchFinder, and evaluate it on 58 real-world CAD models. Our results show that GlitchFinder is particularly effective in identifying slicing issues due to small features, can highlight differences in how popular slicers (Cura and PrusaSlicer) slice the same model, and can identify cases where mesh repair tools (MeshLab and Meshmixer) introduce new errors during repair.

Figures

Figures reproduced from arXiv: 2509.00699 by the authors.

Figure 1
Figure 1. 3D printed mechanical part (center) diverges from the original design (left) due to thin walls. The [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. (Left) GlitchFinder’s kernel first reconstructs a set of cuboids from a G-code program to denote it. From the reconstructed cuboids, GlitchFinder then generates a point cloud. (Right) This kernel can then be used for comparing two G-code programs to generate a difference heatmap and a difference distribution graph. As later sections will show, both model invariant checking and differential testing can be reduced to … view at source ↗
Figure 3
Figure 3. Left to right: high-level CAD design, triangle mesh, a preview of the generated G [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (12 more)
Figure 4
Figure 4. Figure 4: Syntax of the subset of G-code this paper targets: linear motion generated by 3D printing slicers. We define gcodeℎ 𝑑 to be a G-code program whose layer height set to ℎ and which is generated for a 3D printer whose extruder nozzle has diameter 𝑑 [PITH_FULL_IMAGE:figur…
Figure 5
Figure 5. Figure 5: (Left) Top view of the cuboid shown to the right. [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Big step operational semantics of gcodeℎ 𝑑 . From [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Artifacts at different stages of processing: the input model whose G [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Hausdorff distance (𝑦-axis) vs sampling gap (𝑥-axis) with and without floating point error handling. other does not. However, we observe that many such cases arise as side effects of discretization and quantization [32, 79] or floating-point errors. To avoid labeling t…
Figure 9
Figure 9. Figure 9: Heatmap and distance distribution visualization: the bottom row uses spatial averaging. [PITH_FULL_IMAGE:figures/full_fig_p012_9.png]
Figure 10
Figure 10. Figure 10: Output of GlitchFinder on 12 benchmarks with small feature sizes. We omit the axis labels for space — 𝑥-axis is distance and 𝑦-axis is #unit boxes (same as elsewhere). Dark red regions highlight small features due to which they failed to be sliced correctly. Lines to …
Figure 11
Figure 11. Figure 11: Output of GlitchFinder on the 24 of 33 non-watertight benchmarks. The dark red regions highlight parts that caused slicing to fail. We omit the axis labels for space — 𝑥-axis is distance and 𝑦-axis is #unit boxes. Lines to the right in the distribution graphs and red …
Figure 12
Figure 12. Figure 12: Continuation of [PITH_FULL_IMAGE:figures/full_fig_p018_12.png]
Figure 13
Figure 13. Figure 13: Output of GlitchFinder on the 5 benchmarks with flipped normals. The dark red regions highlight parts that caused slicing to fail. Lines to the right in the distribution graphs and red lines have the same meaning as [PITH_FULL_IMAGE:figures/full_fig_p018_13.png]
Figure 14
Figure 14. Figure 14: Output of GlitchFinder on 6 error-free models: the slightly left-skewed / approximate normal distance graph suggests that the differences are due to unwanted errors. problems by inspecting the preview of the G-code (that most slicers support) to detect “overhangs” tha…
Figure 15
Figure 15. Figure 15: Comparing GlitchFinder’s running time to estimated print times across all 56 benchmarks. Plots are shown in log scale, time is in seconds. This section evaluates our second claim that by comparing gcodeℎ 𝑑 programs, GlitchFinder finds differences between slicers and c…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

125 extracted references · 63 canonical work pages

  1. [1]

    Rep-rap Contributors . 2025. G-code - RepRap. https://reprap.org/wiki/G-code

    2025

  2. [2]

    Aceface. 2021. Model after slicing has gaps. Any tips how to fix? https://forum.prusa3d.com/forum/prusaslicer/model- after-slicing-has-gaps-any-tips-how-to-fix/

    2021

  3. [3]

    AircreteHarry. 2024. Cura makes rounded parts flat after slicing and some parts disappear. https: //community.ultimaker.com/topic/45609-cura-makes-rounded-parts-flat-after-slicing-and-some-parts-disappear- anyone-know-what-setting-to-use-to-fix-problem/#comment-334277

    2024

  4. [4]

    John Altidor, Jack Wileden, Jeffrey McPherson, Ian Grosse, Sundar Krishnamurty, Felicia Cordeiro, and Audrey Lee-St. John. 2011. A Programming Language Approach to Parametric CAD Data Exchange (IDETCCIEC, Vol. Volume 2: 31st Computers and Information in Engineering Conference) . 779–791. https://doi.org/10.1115/DETC2011-48530

    work page doi:10.1115/detc2011-48530 2011

  5. [5]

    Aspert, D

    N. Aspert, D. Santa-Cruz, and T. Ebrahimi. 2002. MESH: measuring errors between surfaces using the Hausdorff distance. In Proceedings. IEEE International Conference on Multimedia and Expo , Vol. 1. 705–708 vol.1. https://doi.org/ 10.1109/ICME.2002.1035879

    work page arXiv 2002

  6. [6]

    Autodesk App Store. 2017. MakePrintable Mesh Repair for Fusion 360. https://apps.autodesk.com/FUSION/en/Detail/ Index?id=4108920185261935100&appLang=en&os=Win64. Accessed: 2025-03-25

    2017

  7. [7]

    Autodesk Inc. 2025. Autodesk Netfabb. https://www.autodesk.com/products/netfabb/overview. Accessed: 2025-03-25

    2025

  8. [8]

    Silvia Badini, Stefano Regondi, Emanuele Frontoni, and Raffaele Pugliese. 2023. Assessing the capabilities of ChatGPT to improve additive manufacturing troubleshooting. Advanced Industrial and Engineering Polymer Research 6, 3 (2023), 278–287. https://doi.org/10.1016/j.aiepr.2023.03.003

    work page doi:10.1016/j.aiepr.2023.03.003 2023

Show all 125 references
  1. [9]

    Felix W Baumann, Martin Schuermann, Ulrich Odefey, and Markus Pfeil. 2017. From GCode to STL: Reconstruct Models from 3D Printing as a Service. IOP Conference Series: Materials Science and Engineering 280, 1 (dec 2017), 012033. https://doi.org/10.1088/1757-899X/280/1/012033

    2017 doi

  2. [10]

    Beelzemon. 2024. Pieces of model disappear upon slicing. https://community.ultimaker.com/topic/44843-pieces-of- model-disappear-upon-slicing/#comment-329547

    2024

  3. [11]

    Birsan and D

    T. Birsan and D. Tiba. 2006. One Hundred Years Since the Introduction of the Set Distance by Dimitrie Pompeiu. In System Modeling and Optimization , F. Ceragioli, A. Dontchev, H. Futura, K. Marti, and L. Pandolfi (Eds.). Springer US, Boston, MA, 35–39

    2006

  4. [12]

    Jakub Bryła. 2021. The influence of the MEX manufacturing parameters on the tensile elastic response of printed elements. Rapid Prototyping Journal 27, 1 (2021), 187–196. https://doi.org/10.1108/RPJ-02-2020-0034

    2021 doi

  5. [13]

    Jakub Bryła and Adam Martowicz. 2021. Study on the Importance of a Slicer Selection for the 3D Printing Process Parameters via the Investigation of G-Code Readings. Machines 9, 8 (2021). https://doi.org/10.3390/machines9080163

    2021 doi

  6. [14]

    buteomont. 2024. Model looks different when viewed in Preview vs Prepare. https://github.com/Ultimaker/Cura/ issues/19223

    2024

  7. [15]

    Canon182. 2022. Slicing Incorrectly. https://github.com/Ultimaker/Cura/issues/11733

    2022

  8. [16]

    David Cao, Rose Kunkel, Chandrakana Nandi, Max Willsey, Zachary Tatlock, and Nadia Polikarpova. 2023. babble: Learning Better Abstractions with E-Graphs and Anti-unification. Proc. ACM Program. Lang. 7, POPL, Article 14 (Jan. 2023), 29 pages. https://doi.org/10.1145/3571207

    2023 doi

  9. [17]

    caretdashcaret. 2014. MeshRepairTestModels. https://github.com/caretdashcaret/MeshRepairTestModels/tree/ master?tab=readme-ov-file

    2014

  10. [18]

    Molly Aubrey Carton, Chandrakana Nandi, Adam Anderson, Haisen Zhao, Eva Darulova, Dan Grossman, Jeffrey Ian Lipton, Adriana Schulz, and Zachary Tatlock. 2021. A Roadmap Towards Parallel Printing for Desktop 3D Printers. In Proceedings of the 2021 International Solid Freeform F...

    2021 doi

  11. [19]

    catherinesays. 2023. Slicing problems - Parts of Print Missing. https://forum.prusa3d.com/forum/original-prusa-i3- mmu2s-mmu2-how-do-i-print-this-printing-help/slicing-problems-parts-of-print-missing/

    2023

  12. [20]

    CRigio83. 2024. Ultimaker doesn’t slice all the model. https://community.ultimaker.com/topic/45504-ultimaker- dont-slice-all-the-model/#comment-333597

    2024

  13. [21]

    crysxd. 2024. Circle geometry damaged in slicing process. https://github.com/Ultimaker/Cura/issues/6998

    2024

  14. [22]

    CubeBox391. 2022. Some parts of model disappear after slicing. https://community.ultimaker.com/topic/41818-some- parts-of-model-disapear-after-slicing/#comment-313826

    2022

  15. [23]

    Cura. 2024. Cura Software. https://ultimaker.com/en/products/cura-software

    2024

  16. [24]

    D0GG0. 2023. Missing parts. https://community.ultimaker.com/topic/44400-missing-parts/

    2023

  17. [25]

    Darkglowing. 2022. I need help with slicing Archicad model. https://community.ultimaker.com/topic/39792-i-need- help-with-slicing-archicad-model/

    2022

  18. [26]

    Delfs, M

    P. Delfs, M. Tows, and H.-J. Schmid. 2016. Optimized build orientation of additive manufactured parts for improved surface quality and build time.Additive Manufacturing 12 (2016), 314–320. https://doi.org/10.1016/j.addma.2016.06.003 Special Issue on Modeling & Simulation for A...

    2016 doi

  19. [27]

    Delphi-FPC-Lazarus. 2022. Slicing failed with an unexpected error. https://github.com/Ultimaker/Cura/issues/12975

    2022

  20. [28]

    Dolenc and I

    A. Dolenc and I. Mäkelä. 1994. Slicing procedures for layered manufacturing techniques. Computer-Aided Design 26, 2 (1994), 119–126. https://doi.org/10.1016/0010-4485(94)90032-9

    1994 doi

  21. [29]

    Tao Du, Jeevana Priya Inala, Yewen Pu, Andrew Spielberg, Adriana Schulz, Daniela Rus, Armando Solar-Lezama, and Wojciech Matusik. 2018. InverseCSG: automatic conversion of 3D models to CSG trees. ACM Trans. Graph. 37, 6, Article 213 (Dec. 2018), 16 pages. https://doi.org/10.11...

    2018

  22. [30]

    Dmitry Duplyakin, Robert Ricci, Aleksander Maricq, Gary Wong, Jonathon Duerig, Eric Eide, Leigh Stoller, Mike Hibler, David Johnson, Kirk Webb, Aditya Akella, Kuangching Wang, Glenn Ricart, Larry Landweber, Chip Elliott, Michael Zink, Emmanuel Cecchet, Snigdhaswin Kar, and Pra...

    2019

  23. [31]

    etherbrat. 2024. Infill leaks out of a manifold solid. https://github.com/Ultimaker/Cura/issues/18079

    2024

  24. [32]

    Wang, Jonàs Martínez, Sara Mcmains, Marc Alexa, Brian Wyvill, and Sylvain Lefebvre

    Jimmy Etienne, Nicolas Ray, Daniele Panozzo, Samuel Hornus, Charlie C.L. Wang, Jonàs Martínez, Sara Mcmains, Marc Alexa, Brian Wyvill, and Sylvain Lefebvre. 2019. CurviSlicer: Slightly curved slicing for 3-axis printers. ACM Transactions on Graphics 38, 4 (Aug. 2019), 1–11. ht...

    2019

  25. [33]

    Ette. 2024. EnragedRabbitProject. https://github.com/EtteGit/EnragedRabbitProject

    2024

  26. [34]

    Fabio3rs. 2024. Thread from a bottlecap slicing incorrectly. https://github.com/Ultimaker/Cura/issues/16886

    2024

  27. [35]

    Faklam. 2019. Power Bank - 18650x3. https://www.thingiverse.com/thing:3661158

    2019

  28. [36]

    Cobb, and Nadya Peek

    Frikk H Fossdal, Vinh Nguyen, Rogardt Heldal, Corie L. Cobb, and Nadya Peek. 2023. Vespidae: A Programming Framework for Developing Digital Fabrication Workflows. In Proceedings of the 2023 ACM Designing Interactive Systems Conference (, Pittsburgh, PA, USA,) (DIS ’23). Associ...

    2023

  29. [37]

    Andrew Galbreath. 2023. Missing Layers after slicing. https://forum.prusa3d.com/forum/prusaslicer/missing-layers- after-slicing/

    2023

  30. [38]

    Amabel García Domínguez, Juan Claver Gil, Jorge Ayllon Perez, Marta Marin, and Eva Rubio. 2023. NC Toolpath Generation and Optimization from 3D Point Cloud in Reverse Engineering. 204–212. https://doi.org/10.4028/p-SRc0bO

    2023 doi

  31. [39]

    Neil Gershenfeld. 2024. Rapid-Prototyping of Rapid-Prototyping Machines:How to Make Something that Makes (almost) Anything. https://fab.cba.mit.edu/classes/865.21/topics/path_planning/additive.html

    2024

  32. [40]

    Gianpy86. 2021. Slicing error. https://github.com/prusa3d/PrusaSlicer/issues/7620

    2021

  33. [41]

    Iddo Hanniel, Adarsh Krishnamurthy, and Sara McMains. 2012. Computing the Hausdorff distance between NURBS surfaces using numerical iteration on the GPU. Graphical Models 74, 4 (2012), 255–264. https://doi.org/10.1016/j. gmod.2012.05.002 GMP2012

    2012 doi

  34. [42]

    Yumeng He, Chandrakana Nandi, and Sreepathi Pai. 2025. Artifact for Formalizing Linear Motion G-code for Invariant Checking and Differential Testing of Fabrication Tools. https://doi.org/10.5281/zenodo.16595028

    2025 doi

  35. [43]

    Yumeng He, Chandrakana Nandi, and Sreepathi Pai. 2025. GlitchFinder. GitHub repository. https://github.com/ ymh1003/GlitchFinder

    2025

  36. [44]

    Yumeng He, Chandrakana Nandi, and Sreepathi Pai. 2025. GLITCH_scripts. GitHub repository. https://github.com/ ymh1003/GLITCH_scripts

    2025

  37. [45]

    Yumeng He, Chandrakana Nandi, and Sreepathi Pai. 2025. tricky-3d-models: A benchmark suite for 3D CAD models that are hard to print. GitHub repository. https://github.com/chandrakananandi/tricky-3d-models Commit history accessed 27 commits as of August 18, 2025

    2025

  38. [46]

    Nathaniel Hudson, Celena Alcock, and Parmit K. Chilana. 2016. Understanding Newcomers to 3D Printing: Moti- vations, Workflows, and Barriers of Casual Makers. In Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems (San Jose, California, USA) (CHI ’16)....

    2016

  39. [47]

    D. P. Huttenlocher, G. A. Klanderman, and W. A. Rucklidge. 1993. Comparing Images Using the Hausdorff Distance. IEEE Trans. Pattern Anal. Mach. Intell. 15, 9 (sep 1993), 850–863. https://doi.org/10.1109/34.232073

    1993 doi

  40. [48]

    Jaggana69. 2024. Missing layer. https://github.com/prusa3d/PrusaSlicer/issues/12074

    2024

  41. [49]

    Jasvijay. 2023. Error Rendering object. https://community.ultimaker.com/topic/44310-error-rendering-object/ #comment-326324

    2023

  42. [50]

    Anushrut Jignasu, Kelly Marshall, Baskar Ganapathysubramanian, Aditya Balu, Chinmay Hegde, and Adarsh Kr- ishnamurthy. 2023. Towards Foundational AI Models for Additive Manufacturing: Language Models for G-Code Debugging, Manipulation, and Comprehension. arXiv:2309.02465 [cs.SE]

    2023 arXiv

  43. [51]

    jmgk77. 2022. Incorrect slicing. https://github.com/Ultimaker/Cura/issues/11702

    2022

  44. [52]

    Kenny Jones, David Charatan, Paul Guerrero, Niloy J

    R. Kenny Jones, David Charatan, Paul Guerrero, Niloy J. Mitra, and Daniel Ritchie. 2021. ShapeMOD: macro operation discovery for 3D shape programs. ACM Transactions on Graphics 40, 4 (July 2021), 1–16. https://doi.org/10.1145/ 3450626.3459821

    2021

  45. [53]

    jvos1. 2024. Sliced model missing layers. https://github.com/Ultimaker/Cura/issues/7316. 328:30 Yumeng He, Chandrakana Nandi, and Sreepathi Pai

    2024

  46. [54]

    Community Klipper. 2024. Klipper 3D. https://www.klipper3d.org/

    2024

  47. [55]

    Thomas Kramer, Frederick Proctor, and Elena Messina. 2000. The NIST RS274NGC Interpreter - Version 3. https: //tsapps.nist.gov/publication/get_pdf.cfm?pub_id=823374

    2000

  48. [56]

    Kryszyn. 2022. Unknown slicing error. https://github.com/Ultimaker/Cura/issues/13339

    2022

  49. [57]

    Vu Le, Mehrdad Afshari, and Zhendong Su. 2014. Compiler validation via equivalence modulo inputs. SIGPLAN Not. 49, 6 (June 2014), 216–226. https://doi.org/10.1145/2666356.2594334

    2014

  50. [58]

    leonirz. 2024. Wrong PREVIEW. https://github.com/Ultimaker/Cura/issues/5927

    2024

  51. [59]

    Buswell, Philip J

    Sungwoo Lim, Richard A. Buswell, Philip J. Valentine, Daniel Piker, Simon A. Austin, and Xavier De Kestelier. 2016. Modelling curved-layered printing paths for fabricating large-scale construction components.Additive Manufacturing 12 (2016), 216–230. https://doi.org/10.1016/j....

    2016 doi

  52. [60]

    Marco Livesu, Stefano Ellero, Jonàs Martínez, Sylvain Lefebvre, and Marco Attene. 2017. From 3D models to 3D prints: an overview of the processing pipeline. Computer Graphics Forum 36, 2 (2017), 537–564. https://doi.org/10. 1111/cgf.13147 arXiv:https://onlinelibrary.wiley.com/...

    2017 doi

  53. [61]

    lyrana. 2021. Missing middle section when slicing part on its side? https://community.ultimaker.com/topic/37996- missing-middle-section-when-slicing-part-on-its-side/

    2021

  54. [62]

    Macattack124. 2022. Missing Part of Model when Sliced in Cura. https://community.ultimaker.com/topic/42198- missing-part-of-model-when-sliced-in-cura/#comment-315758

    2022

  55. [63]

    Maccraft123. 2023. Missing part of a model after slicing. https://github.com/prusa3d/PrusaSlicer/issues/11124

    2023

  56. [64]

    Liane Makatura, Michael Foshey, Bohan Wang, Felix HähnLein, Pingchuan Ma, Bolei Deng, Megan Tjandrasuwita, Andrew Spielberg, Crystal Elaine Owens, Peter Yichen Chen, Allan Zhao, Amy Zhu, Wil J Norton, Edward Gu, Joshua Jacob, Yifei Li, Adriana Schulz, and Wojciech Matusik. 202...

    2023 arXiv

  57. [65]

    MarlinFirmware. 2024. Marlin Firmware - A Really Good 3D Printer Driver. https://marlinfw.org/

    2024

  58. [66]

    Matto. 2024. Ultimaker Cura slicing bug. https://forum.core-electronics.com.au/t/ultimaker-cura-slicing-bug/6864/2

    2024

  59. [67]

    mcboeing. 2019. Prusa Slicer errors. https://github.com/prusa3d/PrusaSlicer/issues/3036

    2019

  60. [68]

    michael O´keefe91. 2022. Geometry problem with my model. https://forums.sketchup.com/t/geometry-problem- with-my-model/202390

    2022

  61. [69]

    H T Baharudin, C N A Jaafar, and M I S Ismail

    M K A Mohd Ariffin, N A Sukindar, B.T. H T Baharudin, C N A Jaafar, and M I S Ismail. 2018. Slicer Method Comparison Using Open-source 3D Printer. IOP Conference Series: Earth and Environmental Science 114, 1 (jan 2018), 012018. https://doi.org/10.1088/1755-1315/114/1/012018

    2018 doi

  62. [70]

    muellerbru. 2020. Thin Wall not sliced. https://github.com/prusa3d/PrusaSlicer/issues/3708

    2020

  63. [71]

    James R Munkers. 2000. Topology

    2000

  64. [72]

    Chandrakana Nandi, Anat Caspi, Dan Grossman, and Zachary Tatlock. 2017. Programming Language Tools and Techniques for 3D Printing. In2nd Summit on Advances in Programming Languages (SNAPL 2017) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 71) , Benjamin S. ...

    2017 doi

  65. [73]

    Wilcox, Pavel Panchekha, Taylor Blau, Dan Grossman, and Zachary Tatlock

    Chandrakana Nandi, James R. Wilcox, Pavel Panchekha, Taylor Blau, Dan Grossman, and Zachary Tatlock. 2018. Functional Programming for Compiling and Decompiling Computer-aided Design. Proc. ACM Program. Lang. 2, ICFP, Article 99, 31 pages. https://doi.org/10.1145/3236794

    2018 doi

  66. [74]

    Wilcox, Eva Darulova, Dan Grossman, and Zachary Tatlock

    Chandrakana Nandi, Max Willsey, Adam Anderson, James R. Wilcox, Eva Darulova, Dan Grossman, and Zachary Tatlock. 2020. Synthesizing Structured CAD Models with Equality Saturation and Inverse Transformations. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Lang...

    2020 doi

  67. [75]

    nikita090309. 2024. Cura deletes my walls. https://github.com/Ultimaker/Cura/issues/18934

    2024

  68. [76]

    OnShape. 2025. The Leader in Cloud-Native CAD & PDM. https://www.onshape.com/en//

    2025

  69. [77]

    OpenScad. 2014. OpenScad. The Programmers Solid 3D CAD Modeller. http://www.openscad.org/

    2014

  70. [78]

    PolygonBronson. 2022. Missing Layers in Preview (v5.1.0) when Previous Version (v4.13.1) Showed with Same Slicer Settings. https://github.com/Ultimaker/Cura/issues/12967

    2022

  71. [79]

    Alina Pranovich, Sasan Gooran, Jeppe Revall Frisvad, and Daniel Nyström. 2020. Surface discretisation effects on 3D printed surface appearance. CEUR Workshop Proceedings 2688. https://doi.org/10.5281/zenodo.4081343 10th Colour and Visual Computing Symposium , CVCS 2020 ; Confe...

    2020 doi

  72. [80]

    Raven_CDN. 2021. Missing sections of a print in Preview. https://community.ultimaker.com/topic/36060-missing- sections-of-a-print-in-preview/. Formalizing Linear Motion G-Code for Invariant Checking and Differential Testing of Fabrication Tools 328:31

    2021

  73. [81]

    Research Prusa. 2024. An open-source, feature-rich, frequently updated tool that contains everything you need to export the perfect print files for your 3D printer. https://www.prusa3d.com/en/page/prusaslicer_424/

    2024

  74. [82]

    rftghost. 2019. Incorrect slicing of threaded object. https://github.com/Ultimaker/Cura/issues/5582

    2019

  75. [83]

    Rhinoceros. 2024. Design, model, present, analyze, realize. https://www.rhino3d.com/

    2024

  76. [84]

    RobertBagy. 2024. Slicing adds extra roof. https://github.com/Ultimaker/Cura/issues/18913

    2024

  77. [85]

    sadovsf. 2021. Slicer creates holes in sliced model. https://github.com/prusa3d/PrusaSlicer/issues/6290

    2021

  78. [86]

    Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. 2017. CSGNet: Neural Shape Parser for Constructive Solid Geometry.CoRR abs/1712.08290 (2017). arXiv:1712.08290 http://arxiv.org/abs/1712.08290

    2017 arXiv

  79. [87]

    Benjamin Sherman, Jesse Michel, and Michael Carbin. 2019. Sound and robust solid modeling via exact real arithmetic and continuity. Proc. ACM Program. Lang. 3, ICFP, Article 99 (July 2019), 29 pages. https://doi.org/10.1145/3341703

    2019 doi

  80. [88]

    Simplify3D. 2024. Unleash the Power of Additive Manufacturing. https://www.simplify3d.com/

    2024

  81. [89]

    Slic3r. 2024. Slic3r: Open source 3D printing toolbox. http://slic3r.org/

    2024

  82. [90]

    P. Smid. 2003. CNC Programming Handbook: A Comprehensive Guide to Practical CNC Programming . Industrial Press. https://books.google.com/books?id=JNnQ8r5merMC

    2003

  83. [91]

    Sniper-1818. 2023. Unable to slice (tried 5.4 and 5.5). https://github.com/Ultimaker/Cura/issues/17216

    2023

  84. [92]

    Solidworks. 2024. Smarter. Faster. Together. http://www.solidworks.com/

    2024

  85. [93]

    stemsin. 2024. Part of the model is visible in the prepare mode, but does not come in preview. https://github.com/ Ultimaker/Cura/issues/13831

    2024

  86. [94]

    suatbatu. 2023. Car slice failure. https://github.com/Ultimaker/Cura/issues/17571

    2023

  87. [95]

    Blair Subbaraman, Nathaneal Bursch, and Nadya Peek. 2025. It’s Not the Shape, It’s the Settings: Tools for Exploring, Documenting, and Sharing Physical Fabrication Parameters in 3D Printing. In Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems (Yokoh...

    2025

  88. [96]

    Pavel Surynek, Vojtěch Bubník, Lukáš Matěna, and Petr Kubiš. 2025. Object Packing and Scheduling for Sequential 3D Printing: a Linear Arithmetic Model and a CEGAR-inspired Optimal Solver. arXiv:2503.05071 [cs.CG] https: //arxiv.org/abs/2503.05071

    2025 arXiv

  89. [97]

    Ted5855. 2023. Slicing. https://github.com/Ultimaker/Cura/issues/15653

    2023

  90. [98]

    Mohit Tekriwal and Matthew Sottile. 2025. Mechanized Semantics for Correctness of the RS274 Additive Manufactur- ing Command Language. In NASA Formal Methods, Aaron Dutle, Laura Humphrey, and Laura Titolo (Eds.). Springer Nature Switzerland, Cham, 341–359. https://doi.org/10.1...

    2025 doi

  91. [99]

    Freeman, Joshua B

    Yonglong Tian, Andrew Luo, Xingyuan Sun, Kevin Ellis, William T. Freeman, Joshua B. Tenenbaum, and Jiajun Wu

  92. [100]

    tispokes. 2024. Slicing incorrect – closes some holes randomly. https://github.com/Ultimaker/Cura/issues/17797

    2024

  93. [101]

    Jasper Tran O’Leary, Gabrielle Benabdallah, and Nadya Peek. 2023. Imprimer: Computational Notebooks for CNC Milling. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, Germany) (CHI ’23). Association for Computing Machinery, New York, NY,...

    2023

  94. [102]

    Jasper Tran O’Leary, Eunice Jun, and Nadya Peek. 2022. Improving Programming for Exploratory Digital Fabrication with Inline Machine Control and Styled Toolpath Visualizations. In Proceedings of the 7th Annual ACM Symposium on Computational Fabrication (Seattle, WA, USA) (SCF ...

    2022

  95. [103]

    Jasper Tran O’Leary, Chandrakana Nandi, Khang Lee, and Nadya Peek. 2021. Taxon: a Language for Formal Reasoning with Digital Fabrication Machines. In The 34th Annual ACM Symposium on User Interface Software and Technology (Virtual Event, USA) (UIST ’21). Association for Comput...

    2021

  96. [104]

    Nektarios Georgios Tsoutsos, Homer Gamil, and Michail Maniatakos. 2017. Secure 3D Printing: Reconstructing and Validating Solid Geometries using Toolpath Reverse Engineering. InProceedings of the 3rd ACM Workshop on Cyber-Physical System Security (Abu Dhabi, United Arab Emirat...

    2017

  97. [105]

    UltiCa. 2019. Prusa slicer creates wrong g-code; surface is interpreted the wrong way. https://github.com/prusa3d/ PrusaSlicer/issues/3156

    2019

  98. [106]

    Nobuyuki Umetani and Ryan Schmidt. 2013. Cross-sectional structural analysis for 3D printing optimization. In SIGGRAPH Asia 2013 Technical Briefs (Hong Kong, Hong Kong) (SA ’13). Association for Computing Machinery, New York, NY, USA, Article 5, 4 pages. https://doi.org/10.114...

    2013

  99. [107]

    valely97. 2019. Random missing parts in a 3D Model in Cura 4.0.0. https://community.ultimaker.com/topic/27334- random-missing-parts-in-a-3d-model-in-cura-400/. 328:32 Yumeng He, Chandrakana Nandi, and Sreepathi Pai

    2019

  100. [108]

    VBezchleba. 2019. PREPARE TO PREVIEW - A PART OF MODEL MISSING. https://community.ultimaker.com/ topic/28300-prepare-to-preview-a-part-of-model-missing/

    2019

  101. [109]

    virtuwill. 2024. Model seems different after slicing in a bad way. https://community.ultimaker.com/topic/44793- model-seems-different-after-slicing-in-a-bad-way/#comment-329199

    2024

  102. [110]

    Visual Computing Lab, ISTI - CNR. 2025. MeshLab: The Open Source System for Processing and Editing 3D Triangular Meshes. https://www.meshlab.net/. Accessed: 2025-03-25

    2025

  103. [111]

    Voron-0. 2023. A Drive Frame Upper x1. https://github.com/VoronDesign/Voron-0/blob/Voron0.2r1/STLs/A_Drive_ Frame_Upper_x1.stl

    2023

  104. [112]

    Voron-0. 2023. M2 Nut Adapter Rotated x5. https://github.com/VoronDesign/Voron-0/blob/Voron0.2r1/STLs/M2_ Nut_Adapter_Rotated_x5.stl

    2023

  105. [113]

    Voron-0. 2023. Rear Bed Mount Left x1. https://github.com/VoronDesign/Voron-0/blob/Voron0.2r1/STLs/Rear_Bed_ Mount_Left_x1.stl

    2023

  106. [114]

    Voron-0. 2023. Rear Bed Mount Right x1. https://github.com/VoronDesign/Voron-0/blob/Voron0.2r1/STLs/Rear_ Bed_Mount_Right_x1.stl

    2023

  107. [115]

    Voron-0. 2023. Spool Holder x1. https://github.com/VoronDesign/Voron-0/blob/Voron0.2r1/STLs/Spool_Holder_x1. STL

    2023

  108. [116]

    Voron-0. 2023. T8 Nut Block x1. https://github.com/VoronDesign/Voron-0/blob/Voron0.2r1/STLs/T8_Nut_Block_x1. stl

    2023

  109. [117]

    Voron Design Team. 2025. Voron 0 CoreXY 3D Printer. https://github.com/VoronDesign/Voron-0. Accessed: 2025-03-22

    2025

  110. [118]

    Aosen Wang, Tianjiao Wang, Chi Zhou, and Wenyao Xu. 2017. LuBan: Low-Cost and In-Situ Droplet Micro-Sensing for Inkjet 3D Printing Quality Assurance. In Proceedings of the 15th ACM Conference on Embedded Network Sensor Systems (Delft, Netherlands) (SenSys ’17). Association for...

    2017

  111. [119]

    werewolftm. 2024. Cura does not see the hole. https://github.com/Ultimaker/Cura/issues/19537

    2024

  112. [120]

    Wiesiek1952. 2024. Wrong slicing in Windows. https://github.com/prusa3d/PrusaSlicer/issues/12309

    2024

  113. [121]

    Print Thin Walls

    WilmerSuarez. 2024. “Print Thin Walls” keeps failing to slice. https://github.com/Ultimaker/Cura/issues/16726

    2024

  114. [122]

    Kaushik Yanamandra, Guan Lin Chen, Xianbo Xu, Gary Mac, and Nikhil Gupta. 2020. Reverse engineering of 3D printed composite part by toolpath reconstruction. In Proceedings of the American Society for Composites - 35th Technical Conference, ASC 2020 (American Society for Compos...

    2020

  115. [123]

    Zaive. 2020. Fixing bad geometry on a complex mesh. https://blender.stackexchange.com/questions/176139/fixing- bad-geometry-on-a-complex-mesh

    2020

  116. [124]

    M Šljivic, A Pavlovic, M Kraišnik, and J Ilić. 2019. Comparing the accuracy of 3D slicer software in printed enduse parts. IOP Conference Series: Materials Science and Engineering 659, 1 (oct 2019), 012082. https://doi.org/10.1088/1757- 899X/659/1/012082 Received 2025-03-25; a...

    2019 doi

  117. [2019]

    In International Conference on Learning Representations

    Learning to Infer and Execute 3D Shape Programs. In International Conference on Learning Representations

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.