DEV Community: kulman Lab

Overhauling a CAD Engine: Rebuilding Multileader Text Layout & Editor Mechanics

kulman Lab — Thu, 18 Jun 2026 07:15:50 +0000

Hey everyone! 👋

I just shipped a massive architectural overhaul to our Multileader (MLEADER) graphics engine alongside some long-overdue quality-of-life updates to our canvas Text Editor[cite: 1]. Here is a quick look at what changed, why I changed it, and how I solved it[cite: 1].

🛠 1. Moving to Structured Rich Text Data (`TextSegment[]`)

The Problem

Previously, multileaders treated text as a single string block[cite: 1]. This made formatting highly rigid and prone to failure when dealing with native DXF inline codes (\H, \f, \L, etc.)[cite: 1]. Worse yet, a legacy layout constraint meant that only the first line of text would actually render[cite: 1].

The Solution

I completely decoupled text storage from raw string fields[cite: 1]. Multileader content is now processed into an array of typed segments (TextSegment[]), bringing true multi-line and per-character rich text formatting support[cite: 1]. I also isolated the recursive parsing logic into a unified utility: text-parser-utils.ts[cite: 1].

🎨 2. Solving Variable Row Heights & Text Overlaps

The Problem

When text strings contain varying font sizes or special character drops (like g, j, p, y), standard static height offsets cause lines to overlap, clip, or look completely crushed[cite: 1].

The Solution

I migrated from a static "entity-wide" height constant to a dynamic per-row ribbon architecture[cite: 1]:

First-Row Scaling: The attachment offset is now dynamically scaled using the maximum character height of the first row only, preventing inconsistent alignment[cite: 1].
Per-Row Ribbon Bounds: Each row computes its own bounding box on layout passes[cite: 1]. Mixed font sizes on a single line will never bleed into adjacent rows[cite: 1].
Coordinate Tree Alignment: I aligned the rendering coordinate space to mirror our primary canvas Text entity[cite: 1]. This explicitly resolves selection box overflows for unusually tall or accented characters[cite: 1].
Line-Weight Inheritance: Underline thickness now dynamically inherits its thickness from the adjacent leader line weight[cite: 1].

🖱 3. Inline Canvas Text Editor Integration

Building a modern CAD experience means getting rid of modal popups or manual text prompt windows[cite: 1].

Double-Click-To-Edit: Users can now double-click a multileader to activate an in-place text editor directly on the canvas with real-time cursor tracking, character selection, and accurate hit-testing[cite: 1].
Creation Flow Hooks: The moment a user places the final point of a new leader, the application automatically kicks into the inline text editor state right at the text-placement position[cite: 1].
Layout Anchoring: The editor popup accurately anchors to the stub side of the leader[cite: 1]. Frame-resize handles (grips) allow word-wrap behaviors to scale exactly like standard canvas text bodies[cite: 1].

⚡ 4. General UX & Framework Refinements

I polished out some of the most annoying workflow friction points inside the core workspace:

Command Optimization: Commands like Leader+ or Leader- now check your active canvas selection first[cite: 1]. If a valid multileader is highlighted, it bypasses the manual item selection step[cite: 1].
Canvas Focus Locks: Pressing Enter while adjusting the text height input box immediately returns viewport focus back to the canvas context[cite: 1].
The Ghost Height Bug: Fixed a silent bug where modifying the font size on specific multileader elements would run fine but result in a no-op due to a missing internal text height setter[cite: 1].
Clean Closures: Clicking outside the boundaries of an active text editor gracefully closes out and saves the current state without accidentally registering a brand new selection window on your canvas[cite: 1].

Text Editor is live!

kulman Lab — Wed, 10 Jun 2026 13:40:28 +0000

Building a DXF-Compatible Rich Text Editor for a Web-Based CAD Tool

Last week I spent most of my time working on the text editor for my web-based CAD application, https://kulmanlab.com/.

This update was focused on improving DXF compatibility and making text editing more flexible, predictable, and closer to how modern design tools behave.

📌 DXF MText Support

First of all, MText from DXF is now fully supported.

This means you can:

Create your blueprint in any CAD tool of your choice
Export it as DXF
Import it into KulmanLab
And keep text styling preserved

This was an important milestone because DXF text handling is often inconsistent between tools. Preserving formatting improves interoperability and reduces manual rework.

🔄 Unifying Text: One Object Instead of Two

Previously, the system had two separate concepts:

Text
MText

I decided to simplify this.

Now everything is unified into a single Text object.

Why?

A "simple" text entity is essentially just a multiline text object with one line. Maintaining two separate implementations added complexity without much real benefit.

Unifying them makes the system:

Easier to maintain
More predictable
More extensible for future formatting features

✍️ Rich Text Editing Experience

The Text command now supports a more modern editing experience.

When placing text, you can:

Choose font family
Set font size
Apply styles:
- Bold
- Italic
- Strikethrough (more coming soon)

After placement, the text is rendered inside a blue bounding frame, which defines the wrapping area.

Interactive layout control

A live resize handle allows you to adjust wrapping width dynamically
Text reflows instantly as you resize the frame

This makes layout control much closer to what you'd expect from modern design tools rather than traditional CAD text input.

🧠 Smart Cursor & Formatting Behavior

One of the trickier parts was making the cursor behave correctly in a mixed-format text environment.

Now:

Cursor height adapts to the active character style
Cursor position reflects font size changes in real time
Mixed formatting doesn’t break alignment or insertion behavior

This ensures consistent editing even when different styles are applied within the same text block.

📍 Multiple Attachment Points

Text objects now support multiple attachment anchors:

Top-left
Top-right
Bottom-left
Bottom-right
Center (and others)

This makes positioning more flexible, especially in technical drawings where alignment matters.

🎨 Character-Level Styling

One of the more powerful features is fine-grained text styling.

You can now:

Bold individual words
Change font size per character
Mix fonts within a single text object
Combine multiple styles in one sentence

This moves the editor closer to a true rich-text system rather than a simple label tool.

📦 Frame Visibility & Layout Control

A frame toggle allows you to show or hide the bounding box around text.

This is useful for:

Layout debugging
Precise alignment
Clean final rendering

🚀 What’s Next

I believe the application is now usable enough for most basic workflows.

Next step is shifting focus toward:

SEO optimization
Landing page improvements
Product promotion and visibility

The core editing engine is becoming stable enough to support this transition.

💭 Closing Thoughts

Building a text system that behaves consistently across CAD + web constraints turned out to be more complex than expected.

But the result is a much more flexible foundation that should support future features without major rewrites.

If you're interested in web-based CAD or DXF tooling, feel free to check out:

👉 https://kulmanlab.com/

Building an Adaptive Grid & Smart Snapping System for Web CAD

kulman Lab — Tue, 02 Jun 2026 07:04:21 +0000

Hey dev community! 👋

I just rolled out a major feature update to our canvas-based editor: Grid & Snap.

Implementing a basic grid is easy, but making it feel intuitive, performant, and "smart" at any zoom scale requires a bit of math and careful UX prioritization. Here is a breakdown of how I tackled it.

📐 The Adaptive Grid

A major pain point with standard canvas grids is clutter. If you zoom out, the grid lines choke the screen; if you zoom in, they disappear.

To solve this, our new Grid toggle overlays dots or lines that adapt automatically as you zoom.

The Math: It dynamically scales to land on clean, round values (such as $1, 2, 5, 10$… at any power of ten).
The Result: The grid stays perfectly readable and uncluttered whether a user is looking at a macro layout or zooming into micro-details.

🧲 Smart Snapping (With a Hierarchy)

The Snap toggle locks the cursor to the nearest grid point during drawing or editing. However, blindly snapping to a grid can ruin precision when working near existing lines.

To fix this, I implemented a priority hierarchy:

Geometry always wins. Grid snapping only kicks in when the cursor is not already near an endpoint or intersection.

Additionally, I decoupled the features: the two toggles work independently (you can snap to an invisible grid if you prefer a clean UI), and user settings persist across sessions.

📄 Context-Aware Scaling

A grid shouldn't behave the same way in a design workspace as it does on a printable sheet. The system intelligently detects the active workspace mode:

Workspace Mode	Grid Behavior
Layout Mode	Clipped cleanly to the designated paper boundary area.
Inside Viewports	Dynamics shift to seamlessly follow the model's coordinate scale.

How would you approach this?

If you’ve built something similar, how did you handle performance when rendering thousands of grid points on a high-DPI canvas?

I'd love to hear your thoughts or answer any questions about the math behind the adaptive scaling! 👇

Building a Web CAD: How We Implemented Precise X,Y Coordinate Input

kulman Lab — Mon, 01 Jun 2026 08:26:22 +0000

Hey dev community! 👋

We’ve been working hard on kulmanlab.com, a browser-based CAD and drafting tool. One of the biggest challenges in building web-based design tools is matching the precision and keyboard-driven UX that engineers and designers expect from desktop software.

Today, we rolled out a major feature that addresses exactly that: Precise X,Y Coordinate Input.

Here is a look at how we designed the user experience, the logic behind the terminal inputs, and what commands now support it.

🧠 The UX Design: Fast, Keyboard-First Input
When you are deep in a drafting workflow, taking your hands off the keyboard to aim with a mouse ruins your momentum. We wanted a seamless transition between mouse-clicking and typing.

Now, whenever a command asks the user to "pick a point," the terminal prompt dynamically updates to display or enter X,Y.

Here is the exact state machine we implemented for the input flow:

X-Value Entry: The user types digits, decimals (.), or a leading negative sign (-).

The Switch: Pressing , (comma) or Space locks the X value and shifts focus to Y. The terminal UI updates to show [X], [cursor].

Commit: The user types the Y value and hits Enter or Space to instantly plot the point.

Smart Backspacing: Pressing backspace deletes the last digit. If the Y field is completely empty, hitting backspace automatically jumps the user back to editing the X value.

Graceful Cancellation: Pressing Escape clears the coordinate input buffer without breaking or canceling the active tool/command.

🛠️ Scaling It Across the Architecture
Instead of hardcoding this input logic into every single tool, we hooked it directly into our global point-snapping and input-resolution engine. Because of this architectural choice, we were able to instantly scale coordinate entry across almost every tool in the app:

Creation Tools: Line, Polyline, Arc, Circle, Ellipse, Rectangle, Spline (fit & CV), Text

Transformations: Move, Copy, Rotate, Scale, Mirror

Dimensions & Math: Leader, Dimension (linear, aligned, continue), Distance, Angle

Viewports: Rectangle & Copy viewports

Changelog: Streamlined Annotations, Sticky Commands, and UI Polish

kulman Lab — Sun, 31 May 2026 14:26:25 +0000

Hey everyone! We've been hard at work refining the workspace, fixing nagging bugs, and smoothing out user workflows. Here is a comprehensive breakdown of everything that went into the latest release. Check it out https://kulmanlab.com/

🎨 Annotation & Dimensions

Consistent Defaults

To keep your drawings looking uniform without manual tweaking, all dimensions and leaders now use standardized defaults out of the box:

Text height / Arrow size: 12
Text/landing gap: 1
Extension line offset/extension: 5

Fixes & Behavior

Toolbar Property Inheritance: Dimensions (linear, aligned, angular, radius, diameter) and leaders now correctly inherit color, linetype, and lineweight directly from the toolbar.
Under-the-Hood Cleanup: Leaders now extend LinearEntity instead of duplicating fields, keeping our codebase leaner.
Match Properties: This will no longer overwrite your text content (labels/custom text)—only style properties are transferred now.
Arc Command: Now correctly picks up lineweight from the toolbar.

↩️ Leader Editing Improvements

Working with leaders just got a lot more intuitive:

Text Input Navigation: Supports full cursor navigation using ← and → to move through text, and Delete to remove characters at the cursor.
Terminal Prompts: The locked length input is now clearly highlighted in the terminal prompt.
Leader+ (Chain Mode): Add multiple arms sequentially without having to restart the command every single time.
Leader− (Chain Mode): Remove multiple arms sequentially; simply hit Enter or Space to finish.

📋 Productivity & Copy Commands

What is "Sticky Mode"?
Instead of dropping a single object and ending the command, sticky mode keeps the tool active so you can stamp down multiple copies seamlessly.

ViewportCopy

Sticky Mode: Stays active after each copy so you can place multiple viewports consecutively.
Precise Placement: While angle-locked, you can now type a specific distance for exact placement.

Copy Command

Sticky Mode: Stays active after each copy until you manually exit by pressing Enter or Escape.

📐 Fillet & Chamfer

Fillet Persistence: The fillet radius now persists between uses and comes pre-selected so typing immediately replaces it.
Chamfer Persistence: Chamfer distances persist, and typing instantly replaces the pre-selected value.
Polyline Support: Chamfer now works perfectly on polyline corners, and the broken undo functionality has been fully resolved.

🖥️ UI Polish & Enhancements

Model Space & Navigation

Origin Marker: Added at (0,0) in model space, featuring a vibrant accent color and $2\times$ size for better visibility.
Dynamic Feedback: A dynamic angle readout is now shown in the terminal while you are picking your second point.
Layout Tabs: The active tab is now taller for better visual hierarchy, right-clicking opens a context menu, and navigation arrows move your selection.

Terminal & Typography

Terminal UI: Refined with a lighter history border, a full-white placeholder, and a panel-matched border.
Typography: Replaced the old monospace fonts with a clean Arial sans-serif across the entire application for improved readability.

Dialogs & Widgets

Page & Print Managers: Improved label sizes, border radiuses, and overall layout optimization.
Layer & Style Widgets: Updated with refined border radiuses and full-width fill to match modern UI standards.

What do you think of these workflow changes? Are there any specific commands you'd like to see get the "sticky" treatment next? Let us know in the comments below!

Building a Browser-Based 2d AutoCAD web app with Angular (And the Nightmare of DXF)

kulman Lab — Fri, 29 May 2026 13:21:47 +0000

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?

DEV Community: kulman Lab

Overhauling a CAD Engine: Rebuilding Multileader Text Layout & Editor Mechanics

🛠 1. Moving to Structured Rich Text Data (TextSegment[])

The Problem

The Solution

🎨 2. Solving Variable Row Heights & Text Overlaps

The Problem

The Solution

🖱 3. Inline Canvas Text Editor Integration

⚡ 4. General UX & Framework Refinements

Text Editor is live!

Building a DXF-Compatible Rich Text Editor for a Web-Based CAD Tool

📌 DXF MText Support

🔄 Unifying Text: One Object Instead of Two

Why?

✍️ Rich Text Editing Experience

Interactive layout control

🧠 Smart Cursor & Formatting Behavior

📍 Multiple Attachment Points

🎨 Character-Level Styling

📦 Frame Visibility & Layout Control

🚀 What’s Next

💭 Closing Thoughts

Building an Adaptive Grid & Smart Snapping System for Web CAD

📐 The Adaptive Grid

🧲 Smart Snapping (With a Hierarchy)

📄 Context-Aware Scaling

How would you approach this?

Building a Web CAD: How We Implemented Precise X,Y Coordinate Input

Changelog: Streamlined Annotations, Sticky Commands, and UI Polish

🎨 Annotation & Dimensions

Consistent Defaults

Fixes & Behavior

↩️ Leader Editing Improvements

📋 Productivity & Copy Commands

ViewportCopy

Copy Command

📐 Fillet & Chamfer

🖥️ UI Polish & Enhancements

Model Space & Navigation

Terminal & Typography

Dialogs & Widgets

Building a Browser-Based 2d AutoCAD web app with Angular (And the Nightmare of DXF)

From Civil Engineering to a DIY CNC Machine

Project Philosophy: The Power of Static Pages and IndexedDB

Technical Challenges: Geometry and Performance

DXF: A File Format From Hell

What KulmanLab Can Do Today: From MVP to a Working Tool

What’s Next? (The Roadmap)

Primary Use Cases: Who is this for?

Why it fits the workflow:

AI as a Catalyst and Looking Ahead

🛠 1. Moving to Structured Rich Text Data (`TextSegment[]`)