What in the World Have I Done?

I have been using modeling tools since the 1980s.

That isn't a boast so much as an admission of how long I've been waiting for one of them to be the thing I actually wanted. I started on the original CASE tools and have used more or less everything since — the big repositories, the UML suites, the enterprise architecture platforms, and the whole modern generation of browser-based diagrammers.

For about thirty years I've worked as an enterprise and solution architect. Along the way I've built a few tools and extensions of my own, usually because something in front of me was almost right and the gap looked small enough to close myself. That's a good way to find out what these things are actually made of, and it left me with some sympathy for the people who build them. It's harder than it looks.

The frustration

Like most practitioners, I've spent a lot of those years frustrated.

The tools on offer tend to be too expensive, too restrictive, too rigid, too complicated, or unable to scale. Or they sit behind a sales wall, so you can't find out whether one would work for you without first booking a call with someone whose job isn't to answer that question. Or they're simply annoying — not in one dramatic way, but in the small daily ways that accumulate until you stop opening the thing.

It isn't all bad. A few of the modelers I've used have been genuinely good. They made me faster, and more importantly they made it possible to work at a scale I couldn't have managed otherwise. I'm not writing this because nothing out there works.

I'm writing it because of what sits between the two ends of the market.

Diagrammers can't hold an architecture

Drawing tools are cheap, pleasant, and easy to start with. They also fall apart at size, because a picture doesn't know anything.

Draw a box labelled "Orders System" and an arrow to "Customer Database." Lovely. Now — what kind of thing is that box? What kind of arrow is that? Is that connection even allowed? Put two hundred of those across forty diagrams, have someone ask which of them touch customer data, and you're squinting at pictures and hoping.

In any enterprise of a decent size, the architecture is large. It's always large. That is precisely the point at which a drawing tool stops helping you and starts costing you.

Modelers can hold it, but few can adopt them

The serious platforms solve the scale problem properly. They know what your elements are, what may connect to what, and what everything carries. That's real capability and I don't want to undersell it.

But they also tend to be expensive, cumbersome and locked down — hard for an individual practitioner to pick up, and harder still for an organisation to adopt and keep running. The capability is real. Getting to it is the problem, and for most people and most organisations the wall in front of it is simply too high.

So the choice on offer has been: something you can actually use that can't hold your architecture, or something that can hold your architecture that you can't realistically adopt.

I've wanted to do something about that for most of my career. I never really thought I could. Building a modeling tool properly is a serious undertaking, and for a long time the distance between wanting one and being able to make one was not a distance I could cross.

Recently, that changed.

Two things happened at Christmas

The first was that the AI coding tools got suddenly and obviously better.

I'd spent a few years by then learning to build web applications properly, so I had a fair sense of what was involved and roughly how long things took. Around the end of last year the large language models — Claude Code in particular — took a step up that was hard to miss. A lot of people noticed at the same time. I was one of them.

The second was lunch with a colleague.

We were doing the thing architects do when they get together, which is lament the state of the tooling market. Somewhere in that conversation I thought: maybe it's worth another look.

Not maybe I should build one. I'd had that thought before and put it back down. Something narrower and more answerable — were the pieces on the shelf now?

• A diagramming library good enough to build a real canvas on?
• A database that could sync in real time without me running infrastructure to keep it alive?
• UI frameworks, component libraries, and all the unglamorous plumbing in between?
• And the one that actually mattered: was there a modeling framework — a proper, formal one — that I could build an engine on flexible enough to support almost any notation?

All of it open source, or on a subscription that wouldn't need a business case.

So I went and looked.

The answer, somewhat to my surprise, was: well — just maybe.

I kept waiting for the brick wall

So I started. Not with an architecture document or a grand plan — with a Hello World, and then one small piece on top of it, and then another.

What I was building was the core of what became Farkitect: a modeling engine built on the OMG MetaObject Facility, the standard that sits underneath UML and BPMN. That was the answer to the question that had actually mattered over lunch. Every other component on my list was new. MOF had been fully specified for decades. What had changed wasn't the standard — it was everything around it.

I called it Farkitect because the name made me laugh. I've never had a better reason for naming anything.

And the entire time, I was waiting to hit the wall.

I don't mean I was worried about it. I mean I was certain of it. Anyone who has built software for long enough knows the wall — the point where the thing stops being tractable, where each new feature breaks the last three, where you finally meet the problem the tooling can't carry you through. I gave it a fortnight. Maybe a month if I got lucky.

After about three weeks, the core system was working. Real metamodels, real models, real diagrams on a canvas. My reaction wasn't triumph. It was: well, the wall must be close now.

So I kept going.

That was eight months ago. I've been at it on and off ever since, and I still haven't hit it.

What it turned into

Farkitect lets you build structured, visual models backed by real data — not drawings of them.

You define the types of things you care about, how they're allowed to connect, and what properties they carry. Then you model with them, and the tool understands what you've built. It can check your relationships make sense, give you sortable, filterable catalogs of everything in the model, and show you what's connected to what.

The important part is that it's notation-agnostic. There's no single opinion baked in about how you should model the world. Pick a framework you like — ArchiMate, C4, a data-modeling notation — and use it, extend it, or invent your own from scratch. Enterprise architecture today, a data model tomorrow, something domain-specific that nobody else has ever needed on the weekend. Same tool, your rules.

That's what the MOF foundation buys you: "the notation" and "your model" are genuinely separate layers, so you can change either one without the other falling over. Welcome to Farkitecture.

The engine was never the whole job

It was the interesting problem. It wasn't most of the work.

Most of these months went into the scaffolding that turns an engine into something a person can actually use: managing projects, importing and exporting, collaborating with other people, and sharing models and frameworks with them — that last one being the Farketplace, a name I regret nothing about.

Your models stay yours throughout. Everything exports to a .farki file: plain, readable JSON, no binary blobs and no proprietary format. Open one in a text editor and you can see exactly what you've got.

And most recently there's FarkiBot, which lets you point the LLM of your choice at your models — to ask questions about them, write documents from them, or draft whole models from a specification. You bring your own key and use whatever model suits you, from the expensive frontier ones down to the free ones. No lock-in there either.

There's a circularity to that which isn't lost on me. The thing that made this possible to build is now part of what it does.

Will you give it a go?

So that's what I've done. After eight months of banging away at it, I think there's something here worth putting in front of you. It's early, and in places that shows — but it's real, and it works.

Farkitect is free, and it stays free for the foreseeable future.

What I want right now is your feedback, far more than anything else. I might eventually come up with premium features, though I genuinely don't know what they'd be yet. Or I might open source the whole thing — I've never done that before, and I'm curious about it. But none of that means anything if nobody uses it.

If you'd rather skip the philosophy and just start, head to the Farketplace and take a starter kit. There's a fictional yacht company in there waiting to be modeled — it's a long story, and they're good yachts.

So: will you give it a go?