Hey everyone!
My name is Volodymyr, and I’m one of those developers who didn’t just switch careers—I converted my entire past experience into code. Today, I work as a Java Backend Developer. But my degree says "Civil Engineer," and the years I spent hunching over drawings on traditional drafting tables (kulmans) and in AutoCAD eventually sparked my own passion project: Kulman.
From Civil Engineering to a DIY CNC Machine
My journey into IT started when I realized that civil engineering was becoming an endless routine of repetitive tasks that carried a massive amount of liability. And the financial compensation? Well, that's a whole different story. During my final year of university, I started learning Java, and about a year later, I landed my first job as a backend developer.
But that engineering itch never really went away. I fell down the rabbit hole of CNC machines and even ended up building my own custom laser cutter from scratch based on a Ruida controller. I went all-in with a bit of maximalism: I chose a high-power CO₂ laser tube, which meant the entire machine turned out to be quite massive.
Anyone who has ever dealt with laser cutting or CNC milling knows the struggle: the path from an idea to a finished product often forces you through "monstrous" software. You either have to shell out for an expensive AutoCAD or SolidWorks license, or suffer through free alternatives with terrible UX. My goal was to build a tool that opens in a single second, requires absolutely no registration, and lets you prepare a file for your machine directly in the browser.
Project Philosophy: The Power of Static Pages and IndexedDB
The core principle behind KulmanLab is maximum autonomy. The project is hosted on Firebase and runs purely as a static site.
Why skip the backend?
- Privacy-First: Your drawings belong to you. They are never saved on a server or transmitted over the network. All processing happens locally on your machine.
- Zero Maintenance Costs: Eliminating server-side logic means the project can exist entirely without annoying ad banners or paid subscriptions. My only ongoing cost is the domain name.
- Offline-First: Using IndexedDB, I built a reliable autosave system. Even if you accidentally close your browser or experience a sudden power outage, your files and full edit history remain completely safe in your local browser storage. It’s essentially your own personal, local "cloud." The moment you open a new DXF file or start a project from scratch, everything loads instantly, and your previous work is always right there waiting for you.
To keep the UX familiar and efficient, I chose a classic AutoCAD-style interface: commands can be triggered directly from the keyboard, with prompts and inputs guided by a terminal at the bottom of the screen. While this command-line workflow might have a slight learning curve for total beginners, it drastically speeds up production for anyone used to drafting, as you don't have to constantly hunt for the right button on a toolbar.
Technical Challenges: Geometry and Performance
Three years ago, when I first started this journey, I became fascinated by applied geometry problems—things like finding the intersection point between two lines, or a line and an ellipse. I found myself diving deep into the mathematical functions of geometric shapes, deriving systems of equations, and translating them into code. The ability to immediately see the visual results of my math on the frontend was incredibly motivating. It was exactly the kind of instant gratification I felt was missing in backend development.
For development, I chose a combo of HTML5 Canvas + Angular. Why Angular? To be honest, I was completely disconnected from the mainstream frontend ecosystem at the time. With my backend background, TypeScript felt visually close to Java, and Angular’s structured component approach made it easy to isolate every single "button command." On top of that, two-way data binding dramatically simplified how real-time changes are mirrored on the screen while editing shapes. I know picking this specific stack might raise some eyebrows among frontend purists, but back then, I gave myself exactly 20 minutes to make a choice so I could just start building. My biggest fear was getting stuck in "paralysis by analysis" looking for the perfect tool and losing my momentum. Fortunately, it paid off—three years later, dedicating just a few hours a week, my passion for this hobby project is as strong as ever.
When I started, I expected the browser's hardware limitations to quickly become a bottleneck. When you have thousands of objects (lines, arcs, splines) rendering simultaneously, everything still needs to feel buttery smooth. However, I discovered that the ceiling for optimization is practically limitless. Today, I'm convinced that a mid-range laptop can comfortably crunch up to 1 million elements without breaking a sweat. Thanks to a series of foundational optimizations, KulmanLab can already handle upwards of 100,000 objects seamlessly.
The most exciting engineering challenges so far have been Grips (control points) and Snapping (object snaps). In CAD software, you can't just click "somewhere close"—the engine must instantly and precisely snap to the exact center of a circle, the endpoint of a spline, or the intersection of two lines. To keep this running fast on large-scale drawings, I implemented spatial indexing. Instead of looping through all 100,000 objects with every single pixel movement of the mouse, the engine queries sorted arrays across X and Y coordinates. This spatial lookup keeps the performance locked at a stable 60 FPS, even on highly complex layouts.
For insights, I rely on Google Analytics with custom events. This helps me track which tools and commands are used most frequently, completely respecting user privacy without ever touching or seeing the contents of their local files.
DXF: A File Format From Hell
A lot of developers assume that parsing a DXF file is the hardest part. In reality, reading it is the easy piece. The true nightmare begins when you have to export it—generating a perfectly valid file that won't throw errors in AutoCAD or cause a notoriously picky CNC controller to crash.
To give you an idea, here is a snippet of a valid DXF structure. The format is a legacy, strict sequence of key-value pairs where every single key and value must occupy its own separate line. For instance, you might have a key of 4 with an empty value, followed by key 1001 paired with the value AcadAnnotative.
0
STYLE
5
DC
330
3
100
AcDbSymbolTableRecord
100
AcDbTextStyleTableRecord
2
Annotative
70
0
40
0.0
41
1.0
50
0.0
71
0
42
0.2
3
arial.ttf
4
1001
AcadAnnotative
1000
AnnotativeData
1002
{
1070
1
1070
1
1002
}
As you can see, Autodesk has absolutely no problem duplicating identical keys for a single object, and empty rows acting as values are practically a "standard." The order of the entries matters—except when it doesn't. The whole format feels incredibly chaotic and unpredictable.
Why is this so difficult? The real trap of DXF lies in its group codes. The exact same code can mean an X-coordinate for a line, a radius for a circle, or a layer name, completely depending on the context and the section you are in. On top of that, AutoCAD is notoriously sensitive to the sequence of these codes. If you accidentally mix up the order of parameters in the HEADER or TABLES section, your file instantly turns into garbage that no CAD editor on earth will open.
Another massive challenge is supporting Splines. While a basic line is defined by just two points, splines require control vertices (CVs), knot vectors, and weights. Autodesk’s official documentation covers this only superficially. In practice, I’ve had to do a lot of reverse-engineering on native AutoCAD files to figure out why a spline that renders flawlessly in my browser turns into a chaotic, mangled curve after being exported.
What KulmanLab Can Do Today: From MVP to a Working Tool
Here is what is fully functional right now:
- Full 2D Primitive Support: Straight lines, circles, arcs, ellipses, and polylines. Text rendering hasn't received as much attention yet, because handling fonts accurately in CAD engines is a whole separate rabbit hole. I plan to tackle that down the road.
- Complex Splines: This was my own little engineering victory. I implemented two curve-building modes: Fit points (where the curve passes exactly through the specified coordinates) and Control Vertices (CV) (where you shape the curve using a control polygon). This is absolutely critical for modeling intricate paths meant for laser cutting.
- Transformation Tools: The classic design toolkit you can't live without—Move, Copy, Scale, Mirror, and Rotate. Every single one of them hooks perfectly into the object snapping logic.
- Project Structuring: Full support for Layers. You can manage visibility, assign distinct colors, and set line types. This makes it easy to work on complex drawings where you need to separate your laser cutting profiles from engraving lines.
- Precision and Insights: The engine automatically calculates geometric intersection points and allows for precision scaling—essential baseline features for getting a drawing production-ready.
What’s Next? (The Roadmap)
The project evolves alongside my primary backend job, but the roadmap is ambitious:
- Enhanced Snapping: Making object snaps even smarter and faster, including adding polar tracking.
- SVG Export: While the primary focus remains DXF generation for machinery, being able to quickly save a blueprint as a SVG for printouts or documentation reports is an essential feature.
- UX Refinements: I regularly analyze anonymized custom events in Google Analytics to see exactly where users stumble so I can continually streamline the workflow.
Primary Use Cases: Who is this for?
KulmanLab isn't trying to kill off AutoCAD. My goal is to provide a fast, nimble "Swiss Army knife" for people who just need to get a specific job done right here, right now, without waiting for a heavy engineering suite to load.
I see two primary user bases:
- The CNC and Laser Cutting Community: Makers, hobbyists, and shop operators who just need to quickly open a DXF file, verify dimensions, tweak a boundary, or clean up stray lines before sending the file to their machine controller.
- Students and Technical Education: Picture a student who needs to quickly draft an engineering schema for a lab report or term project. Instead of hunting down pirated software or jumping through hoops for a one-semester student license, they can just open their browser, sketch the diagram, and instantly export it as a high-resolution PNG or JPEG. It's incredibly fast and frictionless.
Why it fits the workflow:
- Zero Latency: You open the URL and you are drafting a second later.
- Versatile Exports: In addition to clean DXF output, you can generate crisp raster images to paste directly into report documents like Word or Google Docs.
- Zero Barriers: No sign-ups, no email verification, and no credit cards.
AI as a Catalyst and Looking Ahead
While KulmanLab has been in development for three years, the last six months have been a massive turning point. Leveraging modern AI coding assistants has drastically accelerated my output. For a solo developer, AI acts as a true force multiplier, turning what used to be a grueling, isolated grind into a fast-paced sprint toward new releases.
Over-engineering and attempting to be everything to everyone is how good software becomes bloated and frustrating to use. Because of that, KulmanLab will stay true to its core philosophy: strictly 2D, strictly fast, and strictly in the browser. No forced registration, no ad banners—just a clean, distraction-free tool that works.
Try it out out here: kulmanlab.com
I would love to hear feedback from fellow developers and engineers in the comments! Have you ever had to wrestle with the DXF format in your own projects? What tools do you typically use when you just need to make a quick, painless edit to a drawing?
