DEV Community: Elliot Silver

Compact Design: a JSON language models can write and Figma can import

Elliot Silver — Fri, 14 Aug 2026 07:57:47 +0000

Don't ask a model to speak Figma's plugin API. Don't ask it for CSS and hope a screenshot is a design.

I wanted a format a model can write, a schema can reject, and Figma can turn into native, editable frames.

That's Compact Design.

It's a small JSON language. @compact-design/core validates, normalizes, lints, and patches it. The Figma plugin is the first adapter. Core never depends on Figma.

Repo: github.com/Elliot727/compact-design

A card looks like this

{
  "canvas": {
    "id": "desktop",
    "name": "Desktop",
    "width": 1440,
    "height": 900,
    "fill": "#F8F5EE"
  },
  "nodes": [
    {
      "id": "card",
      "type": "FRAME",
      "x": 48,
      "y": 48,
      "w": 320,
      "h": 200,
      "fill": "#FFFFFF",
      "cornerRadius": 16,
      "layout": {
        "direction": "VERTICAL",
        "padding": 24,
        "itemSpacing": 12
      },
      "children": [
        {
          "id": "title",
          "type": "TEXT",
          "w": 272,
          "h": 40,
          "text": "A quieter kind of stay.",
          "font": { "family": "Arial", "style": "Bold", "size": 24 },
          "fill": "#23221E"
        }
      ]
    }
  ]
}

Required on a node: w and h. type defaults to FRAME. IDs are generated if you omit them — give anything you'll update later an explicit one.

Hex fills. HUG / FILL / FIXED. Angle gradients. Elevation presets. Variables, styles, components, prototypes, images. One current schema. No version soup.

This is the input API. Not Figma REST. Not a properties wrapper. Not 24px.

What the engine actually does

Compact Design JSON
↓
@compact-design/core
schema → normalize → semantic checks → lint / patch
↓
adapter
↓
Figma today; another tool can implement the same language

Core is ordinary TypeScript. No figma.*, no plugin typings.

import { validate, normalize, lint, applyPatch } from "@compact-design/core";

const result = validate(input);

if (!result.valid) {
  console.log(result.issues);
} else if (result.document) {
  console.log(lint(result.document));
}

Issues come back structured, which is the point if a model is in the loop:

{
  "valid": false,
  "issues": [{
    "severity": "ERROR",
    "code": "SCHEMA_VALIDATION",
    "path": "nodes[0].children[2].layout.direction",
    "message": "must be HORIZONTAL, VERTICAL, or GRID",
    "suggestion": "Use the allowed property type or enum from compact-design.schema.json."
  }]
}

Schema and semantic errors block import. Lint does not. Lint is advisory: contrast, 44px targets, 4px spacing, missing Auto Layout, hard-coded colours, broken prototype destinations.

The plugin does not render a browser thumbnail. A thumbnail would lie about fonts, Auto Layout, masks, and effects. You get counts, matches, and the repair JSON instead.

Create, update, patch, export

Every imported canvas and layer stores its JSON id as plugin data.

• Create new refuses a canvas ID already on the page.
• Update matching IDs replaces matching canvases in place.
• Replace matching canvases rebuilds them from the document you just supplied.
• Export selection writes Compact Design JSON back out.

Full-document update is canvas-granular. A patch is node-granular. Failures roll back — the previous design is cloned first.

{
  "patch": {
    "operations": [
      { "op": "set", "id": "title", "set": { "text": "The same design.\nA different mood." } },
      { "op": "remove", "id": "old-badge" },
      {
        "op": "append",
        "parent": "card",
        "node": {
          "id": "note",
          "type": "TEXT",
          "w": 272,
          "h": 18,
          "text": "UPDATED WITH A JSON PATCH",
          "fill": "#B69B62"
        }
      }
    ]
  }
}

set changes only what you list. Everything else stays put.

Try it

The package is not on npm yet. Build from the repo.

git clone https://github.com/Elliot727/compact-design.git
cd compact-design
npm install
npm run build

In Figma desktop: Plugins → Development → Import plugin from manifest… and pick plugins/figma/manifest.json.

Then paste examples/design-language-showcase.json. It should land as a finished product screen, not an API reference board.

Language docs, schema, and the other fixtures live next to it.

If you generate UI with a model, this is the format I'd actually trust.

MPL-2.0. github.com/Elliot727/compact-design

Your First Real Project – Live Edge Detection with Recording

Elliot Silver — Wed, 31 Dec 2025 17:00:00 +0000

Why This Matters

Edge detection is the "hello world" of serious computer vision – it's where you start tuning parameters, chasing clean lines, and realizing how much time raw OpenCV setups waste.

With vanilla GoCV you'd spend dozens of lines on:

Camera capture loop
Window creation
Mat management (and inevitable leaks)
Keyboard handling
Recording logic

GoCVKit gives you all that for free. You focus only on the pipeline.

Hands-On: Build the Edge Detector

Start from the quick start (if you followed Week #2, you already have this):

# If not done yet
mkdir gocvkit-edge && cd gocvkit-edge
go mod init edge-demo
go get github.com/Elliot727/gocvkit

# main.go – same as always
package main

import (
    "log"
    "github.com/Elliot727/gocvkit"
)

func main() {
    app, err := gocvkit.NewApp("config.toml")
    if err != nil {
        log.Fatal(err)
    }
    defer app.Close()
    app.Run(nil)
}

Now create the star of the show – config.toml:

[app]
window_name = "GoCVKit – Live Edge Detection"
record = true                  # Save processed video automatically
output = "edge_detection.mp4"  # Optional: custom filename

[camera]
device_id = 0
# file = "demo.mp4"            # Uncomment to use a video file instead

[stream]
enabled = false                # Keep off for now – we can enable later

[[pipeline.steps]]
name = "Grayscale"

[[pipeline.steps]]
name = "GaussianBlur"
kernel = 9
sigma = 1.8

[[pipeline.steps]]
name = "Canny"
low = 50
high = 150

Run it:

go run .

Boom – live edge detection window with:

Clean Canny edges
Press f to toggle FPS overlay
Recording started automatically (check your folder for edge_detection.mp4)
Edit any value in config.toml → save → instant update (thanks Week #2!)

Level It Up

Try these live tweaks (no restart needed):

Crank the blur for smoother edges:

   kernel = 15
   sigma = 3

Softer edges:

   low = 30
   high = 100

Add morphology to clean up noise:

   [[pipeline.steps]]
   name = "Dilate"
   kernel = 3
   iterations = 1

Toggle recording on/off live by flipping record = false → save.

Bonus: Add a Simple Overlay with Frame Callback

Want to show current thresholds on screen? Add a tiny callback to main.go:

app.Run(func(frame *gocv.Mat) {
    // Runs on the final processed frame
    gocv.PutText(frame, "Low: 50  High: 150", image.Pt(10, 30),
        gocv.FontHersheyPlain, 1.5, gocv.NewScalar(255, 255, 255, 0), 2)
})

(Recompile once – but now you can hot-reload the text by changing the string and saving config if you make it config-driven later.)

Pro Tips

Recording auto-rotates files if they get too big – no manual management.
Press Esc or q to quit gracefully (resources cleaned up).
Run out of webcam? Swap to a video file by uncommenting file = "demo.mp4".

Try It Yourself

Copy the config above, run it, and start playing. Break it. Fix it live. Feel the speed.

What's your favorite edge detection tweak? Do you prefer strong/thin lines or softer outlines? Drop it in the comments!

The Hot-Reload Magic - Tweak Pipelines Live (No Restarts!)

Elliot Silver — Wed, 17 Dec 2025 17:00:00 +0000

Edit your config.toml while the app is running and watch the pipeline update instantly. No recompiling. No stopping the camera. Pure iteration bliss.

Why This Matters

If you've ever prototyped with raw GoCV (or any OpenCV binding), you know the pain:

Change a threshold or kernel size? Edit code → recompile → restart → wait for camera init.
Takes 10-30 seconds per tweak → kills your flow.
Accidentally leak a Mat? Crash and start over.

GoCVKit fixes this with live config hot-reload. Save config.toml → the running app detects the change → rebuilds the entire pipeline on the fly → you see the result immediately.

It's the closest thing Go has to Jupyter notebooks for computer vision.

How It Works (The Magic Explained)

Under the hood it's simple and robust:

A lightweight file watcher (using fsnotify) monitors config.toml.
On any save, the config is re-parsed.
The pipeline builder recreates all processors with new parameters.
The next frame uses the brand-new pipeline – no frames dropped, no allocations outside the double buffer.

Zero boilerplate for you. Zero leaks guaranteed.

Hands-On: See It Yourself

Fire up the quick start if you haven't already:

mkdir gocvkit-demo && cd gocvkit-demo
go mod init demo
go get github.com/Elliot727/gocvkit

main.go

package main

import (
    "log"
    "github.com/Elliot727/gocvkit"
)

func main() {
    app, err := gocvkit.NewApp("config.toml")
    if err != nil {
        log.Fatal(err)
    }
    defer app.Close()
    app.Run(nil)
}

Create initial config

config.toml

[app]
window_name = "GoCVKit – Hot-Reload Demo"

[[pipeline.steps]]
name = "Grayscale"

[[pipeline.steps]]
name = "Canny"
low = 50
high = 150

Now the fun part:

Window opens showing live Canny edges.
Open config.toml in your editor.
Change high = 150 → high = 300 → save. → Edges instantly thicken.
Replace the entire Canny block with GaussianBlur:

[[pipeline.steps]]
name = "GaussianBlur"
kernel = 15
sigma = 3

Save → blur appears instantly.

Try something wild:

[[pipeline.steps]]
name = "Grayscale"

[[pipeline.steps]]
name = "MedianBlur"
k = 21

No restarts. No code changes. Just pure experimentation.

Pro Tips for Hot-Reload Happiness

Typos? GoCVKit prints clear errors in the terminal but keeps the old pipeline running – no crash.
Add/remove steps freely – the builder handles it gracefully.
Want to test recording too? Flip record = true live and it starts/stops without hassle.

The pipeline itself uses double-buffering so frame processing never blocks or allocates per frame. That's why you get smooth FPS even during reloads.

Try It Yourself

Grab the repo, run the example above, and go wild with the config. Break it on purpose – you'll see how forgiving it is.

What's the first parameter you always tweak in edge detection? Thresholds? Kernel sizes? Tell me in the comments!

Introducing GoCVKit: Zero-Boilerplate Computer Vision in Go

Elliot Silver — Wed, 10 Dec 2025 17:34:35 +0000

Hey there, fellow Gophers! If you’ve worked with computer vision in Go, you know GoCV is fantastic for accessing OpenCV’s power.

But the reality? Boilerplate everywhere: camera setup, Mat management, window handling, resource leaks, and recompiling just to tweak a parameter. It’s not exactly “fun.”

That’s why I created GoCVKit—a modular framework that makes real-time CV prototyping smooth, efficient, and genuinely enjoyable.

What is GoCVKit?
GoCVKit is a clean, idiomatic layer on top of GoCV for live camera or video streams. It handles the heavy lifting so you can focus on ideas, not plumbing.

Key features:
• Zero boilerplate: Full apps in ≤10 lines.
• Hot-reload config: Edit config.toml and changes apply instantly—no restarts.
• Performance-focused: Double-buffered pipelines with zero per-frame allocations.
• Extensible: Built-in processors (Grayscale, GaussianBlur, Canny, Sobel, etc.) plus easy custom filters.
• Quality-of-life extras: Video recording, toggleable FPS overlay, frame callbacks, graceful shutdown, and seamless input switching (webcam or file).

Why I Built This
Go is perfect for CV: fast, concurrent, and easy to deploy. But raw GoCV meant rewriting the same scaffolding repeatedly. GoCVKit eliminates that pain, making it ideal for:
• Rapid prototyping
• Teaching and demos
• Live presentations
• Real-time vision apps
• Anyone who wants to stay sane while experimenting

Get Started
go get github.com/Elliot727/gocvkit

Head to the repo for full documentation, processor list, and custom filter guides:
github.com/Elliot727/gocvkit

Star it if it saves you time, contribute if you make it better, and tell your friends—Go deserves a first-class CV experience! 🚀
What real-time CV projects are you working on? Let me know in the comments!

Hey Go devs! Built GoCVKit – a clean, zero-boilerplate OpenCV framework for Go. Hot-reload config, modular pipelines, no leaks, fun live CV apps! 🚀 github.com/Elliot727/gocvkit Star if you like! #golang #opencv

Elliot Silver — Wed, 10 Dec 2025 17:30:07 +0000