G-Code-Assembler

The G-Code Assembler and Viewer enables seamless G-code assembly and STL visualization with a Flask backend and React front-end, offering interactive or notebook-based workflows for efficiency.

Comment

About the Project

The G-Code Assembler and Viewer is a tool for assembling and visualizing G-code commands in a web interface, allowing users to download the result as a watertight STL file. With a Flask backend and a React front-end, the entire project can be launched with a single command, offering a seamless way for users to modify, view, and save their customized G-code outputs.

Inspiration

In previous projects, I frequently encountered challenges when working with G-code files, particularly in reverse-engineering machine-specific specifications. This experience drove me to create an intuitive interface that allows users to assemble and visualize G-code in real-time, bridging the gap for those who may find the traditional command-line G-code tools overwhelming. Additionally, the option to download watertight STL files directly streamlines 3D printing workflows and minimizes setup time for CNC and 3D printing projects.

What I Learned

This project pushed me to explore a combination of front-end and back-end skills, while also expanding my understanding of:

  • G-code Parsing and transformation into STL files.
  • Watertight Mesh Generation: Converting G-code into watertight STL files required a rigorous approach to ensure no open edges, particularly in files with high complexity.
  • High-Performance Computation: Generating STL files with up to 6 million nodes required considerable computing power, and I encountered GPU memory limitations even with a 3090TI at one point.

How I Built the Project

  1. Backend with Flask: The backend is built in Flask, serving as the API layer to handle G-code parsing, transform files, and manage mesh generation. Careful attention was given to optimizing the mesh to create watertight STL files.
  2. Front-end with React: Using React enabled the interactive visualization of G-code sequences. This interactivity helps users preview changes in real-time before committing to final adjustments.
  3. Alternative Notebook Setup: The project includes an alternative Jupyter Notebook (test.ipynb) for users who want to generate STL files directly, bypassing the web interface if necessary.
  4. One-click Setup: For ease of use, the project includes a single-command setup script (run_project.sh for Linux/Mac, run_project.bat for Windows) to get everything running effortlessly.

Challenges Faced

  • Watertight Mesh Files: Ensuring the STL files were watertight was critical, particularly when dealing with larger files. At one point, I handled a mesh with 6 million nodes, pushing my GPU to its limits and running out of memory, even on a 3090TI. This experience underscored the importance of computational efficiency when dealing with complex geometries.
  • Parsing Diverse G-code Variants: Each G-code variant has unique syntax, requiring extensive testing to parse and transform accurately into STL files without introducing mesh errors.

The G-Code Assembler and Viewer makes G-code customization accessible, helping users visualize and download STL files without needing complex command-line operations. I’m excited to see how it performs in the competition, with hopes of winning the 3D printer!

What it Does

The G-Code Assembler and Viewer is an intuitive web-based tool that allows users to assemble and visualize G-code commands in real time. It features a Flask backend and a React front-end to provide a smooth interface for customizing and previewing G-code sequences. Users can also download the result as a watertight STL file, making the tool ideal for integrating into 3D printing workflows. For added flexibility, users can bypass the web interface and use the Jupyter Notebook option to generate STL files directly.

How We Built It

  1. Backend with Flask: The backend API handles G-code parsing and mesh transformations, with a focus on generating watertight STL files to ensure the mesh integrity needed for 3D printing.
  2. Front-end with React: React was used to make the web interface interactive and dynamic, allowing users to preview the STL model of their G-code edits immediately. Each command modification updates the visual preview, making the experience hands-on and user-friendly.
  3. Alternative Jupyter Notebook Interface: For users who prefer working directly with STL files, the test.ipynb notebook provides an alternative, enabling STL file generation without the need for the full web setup.
  4. One-Command Setup: A single setup command (or script) installs dependencies, initializes the Flask backend, and starts the front-end server, making it easy for users to get started quickly regardless of technical background.

Challenges We Ran Into

  • Watertight Mesh Generation: Ensuring the STL files were consistently watertight was critical to prevent issues during printing. At one point, the mesh reached a complexity of around 6 million nodes, pushing the GPU memory limits of my 3090TI and requiring additional optimization steps to handle such large datasets smoothly.
  • Parsing G-code Variants: Since G-code syntax varies across machines, creating a reliable parser for each command variant required significant testing to ensure accurate representation in the STL output.

Accomplishments That We’re Proud Of

  • Scalable Mesh Generation: Despite the complexity, we achieved watertight STL generation for even the largest files, allowing users to confidently integrate the output into any 3D printing pipeline.
  • User-Friendly Interface: The React front-end makes G-code modification accessible, even for those new to the G-code format. Each change is visible in the preview, which helps users learn while experimenting.
  • Efficient Setup and Usage: With the one-command setup and alternative Jupyter notebook option, the project is flexible for different user needs and can be deployed quickly.

What We Learned

  • High-Performance Computation: Handling dense meshes showed us the importance of memory optimization when working with high node counts. Running out of GPU memory on a 3090TI underscored the need for efficient mesh management and memory handling techniques.
  • Advanced Parsing and Transformation Techniques: Parsing G-code and accurately transforming it into STL files required diving deep into the intricacies of G-code commands and learning how to adapt our transformations for various syntactical quirks.

What’s Next for G-Code Assembler

  • Enhanced Command Library: We plan to add a more extensive library of machine-specific G-code variants, making the tool even more versatile across different hardware setups.
  • Expanded 3D Visualization: Incorporating more advanced visualization tools would allow for features like rotating and zooming into specific segments of the mesh, enhancing user interactivity.
  • GPU Optimization Options: Given the high memory demands for larger STL files, we aim to integrate further GPU optimization techniques to improve performance and support even more complex designs.

With these features in place, we hope the G-Code Assembler and Viewer will continue to grow as a valuable resource in the 3D printing community, and we're excited for the chance to win a 3D printer!

Built With

Share this project:

Updates