Wuniq is growing into KaKeKiKoKu. You may see both names during the transition. Read why →

KaKeKiKoKu Studio / Roadmap

Your project is
its knowledge.

KaKeKiKoKu Studio is a knowledge system: you shape your project’s knowledge, on your own or with any AI. This page shows what I plan to do next, in order, and the ideas I keep thinking about.

Last updated

Completed in Studio 1.19

When knowledge changes, see what needs a review.

A decision gets revisited or an assumption stops being true. Since 1.19, KaKeKiKoKu follows the relations already in your project and brings the connected knowledge back to your attention. Read how it came about.

Completed in 1.19

Use the connections
you already have.

You could already follow a relation from a decision to the knowledge connected to it. What was missing was a reminder when that connection needs a fresh look.

Those relations now track reviews. A change that matters flags the knowledge at the other end of every connection, whether the relation points towards the changed block or away from it. Its description explains the connection; the arrow alone cannot tell us which side might be affected.

When you or your AI edit knowledge in Studio, you say whether the change calls for review: Save asks for it, Just save corrects a typo without new alerts and keeps the reviews already waiting. Changes made outside Studio are detected during sync too.

Your AI sees pending reviews when it reads the affected knowledge, and sync lists them by resource. After reviewing, an edit or your conformity puts that knowledge up to date. See how it works in the manual.

Keep track of the knowledge connected to a changing decision.
After “Keep personal data local” changesConcept
  • policies.entity
    • Keep personal data local · changed
      • explained by →Exporting your data
  • export.py
    • What goes into an export · review pending
      • follows →Keep personal data local
  • manual.entity
    • Exporting your data · review pending

ContainsRelates to

Both connected blocks need a review, whichever way their relation points.

Coming next · if all goes well

Five things, in this order.

Five at most: for something new to come in, something else has to go out. The first is under way. Plans change when I learn something new, so read this as an intention, not a promise.

Several new ways of testing, before the label comes off.
1 · Under way

More testing before leaving beta.

Before the beta label comes off, I want to test Studio in ways I haven’t used yet. Each new way of testing so far has found problems the earlier ones couldn’t see.

  • AI sessions on real projects of different kinds, checking the files on disk afterwards.
  • Writes interrupted on purpose, to check what happens when a move or a delete is cut short.
  • Settling the ideas that would change the format, while changing it is still cheap.
  • Keeping your draft safe when your AI changes the block you are editing.

The quality work so far: Checking my work and The Git release.

A link in the chat takes you straight to the block.
2 · Design first

Your AI points you to what matters.

Your AI can already see what you’re looking at. I want the reverse too: when a project grows, it gets hard to know where your AI left something. It should be able to point you to a document, a section or a subsection, and you should get there in one step.

The starting point is the simplest one: a direct link to the block, right there in the chat. It works with any client and stays in the conversation. Colors or a panel, only if that isn’t enough.

To work out: if the AI chooses what you see, it also chooses what you don’t. Everything else has to stay within reach.

Found where people already look.
3 · Outside the app

Easier to find, under the right name.

The best place to be found is where people already look for this. The MCP server and the plugins for Claude Code, Codex and Antigravity are already out there, but some listings still use the old name and an old description. I want them to say what KaKeKiKoKu Studio is today, without breaking the setups that already work.

I’d also like a plugin to work right after installing it, without adding start-up instructions by hand.

Nothing changes in your projects: Wuniq stays as the name of the format, and .wuniq as its extension.

Run the script again, get the clip again.
4 · Outside the app

A first video, built by a script.

Videos made by hand go out of date with every change to the interface. So I want to treat them like code: scenes scripted against a stable demo project and recorded automatically, with on-screen text instead of a voice.

I’ll start with one short clip that proves the whole path, here on the site, before making any more. It has to show what only becomes visible over time: knowledge that drifts, relations that keep their identity, links that repair themselves.

It will show examples you can check for yourself, never a prepared result passed off as automatic.

Open and Quit, always in reach.
5 · After that

A system tray icon.

Close the browser and the engine keeps running, with no sign of it and no visible way to quit. A tray icon would fix that: Open and Quit, nothing more at first.

To work out: Windows 11 tends to hide new icons until you pin them, and plain GNOME needs an extension to show them at all. The desktop icon stays for those cases.

Ideas · No order, no commitment

What I keep thinking about.

Being here doesn’t mean it will be built: each idea first has to show that it’s worth the complexity it adds. These are the ones I’d look at first when a place opens up above, followed by two that need more thought.

Fewer steps to reach the same knowledge.
Exploring

Less work for your AI.

  • Ask for one block of knowledge directly, without looking up the structure first.
  • Review everything a single change affected in one pass, while still seeing why each connection exists.
  • Working notes that change by design, without an out-of-date warning for every line you add.
  • A search that accepts alternative terms, groups long result lists, and can lead from a name in your code to the knowledge that explains it.
Type a name. Choose a match. Open it.
Exploring

Navigate by keyboard.

I want to explore a quick way to open a file, entity, or section by typing part of its name, keeping your hands on the keyboard.

To work out: useful shortcuts can conflict with the browser’s own controls. The key combinations and interaction need investigation before settling on a design.

While you edit it, your AI waits.
Needs study

Protect what you’re editing.

Today you and your AI can change the same resource at the same time, and it’s up to you to coordinate. I’d like to study protecting a resource from AI changes while you edit it in Studio.

To work out: which operations it should stop, how the AI learns why and when to try again, and what happens with several tabs or an abandoned draft.

Trace the incoming links before deciding.
Exploring

See the impact before deleting.

Before removing a resource, its context, or a section, I want a clear view of the incoming references that would be affected, including the names of the blocks and resources they come from.

This can build on the review tracking added in 1.19. The design still needs to make clear which relations would be removed or left unresolved by each kind of deletion.

The aim is to make the affected connections visible before you confirm the deletion. Its scope and interface still need study.

The other end, before and after.
Needs study

See what changed when reviewing.

When a connection needs a review, you know the other end changed, but not what. I’d like to show its earlier version next to the current one, using the backups Studio already keeps.

An open question: a backup may not exist for that exact moment, so this can’t be promised in every case.

Exploring

A tree of files
and knowledge.

The navigation tree used to show only the structure of your folders and files. That structure is already one kind of relation: what contains what. But knowledge also crosses it — a decision shapes several files, a rule applies in more than one place.

Since 1.18, the tree shows both: under each resource and block you see the relations that reach it and the ones it declares, and one click takes you to the real resource, so you can go from a decision to everything it shapes without leaving the navigation. That first version is here.

What I’m exploring next is a view that starts from an entity — a concept, a decision — and unfolds everything connected to it.

From a file explorer to a knowledge explorer.
Files and relations in one treeConcept
  • product/
    • architecture.entity
      • Keep data local
        • constrainsstorage.py
        • constrainssync.py
  • src/
    • storage.py
    • sync.py

ContainsRelates to

Walk from a decision to everything it shapes.

Exploring

The source and its meaning.
Side by side.

I’m exploring a split view that would put an original text or code file alongside its editable context. You could document a function while looking at it, or explain a document with the source still in view.

An adjustable divider would let you choose the balance, then return to a single view when you want the space back.

Write the explanation with the original in sight.
Source + contextConcept
Original file access.ts 
if (!session) {
  return denied;
}

return allowed;
Project knowledge Why this check exists

Access requires a valid session.

Decision

Reject early, before reading any private data.

One place to read the source and explain the reasoning.

A longer horizon

Project knowledge for more people.

Long term

KaKeKiKoKu Studio on macOS.

I would like people on macOS to have access to the same knowledge system: decisions, explanations, and relationships that stay with their work.

This is a longer-term direction, with no release date. It needs time for proper platform testing and ongoing care alongside Windows and Linux.

The same idea. A wider welcome.
Already done

What recent releases brought.

Each release has its story on the blog. Together they show where the work has been going: first a way to follow connected knowledge, then checks you can run yourself, then files that travel well.

Completed in 1.22

Context files that travel well.

Format 1.2 keeps machine-specific file times and sizes out of knowledge files. The same content with Windows or Linux line endings no longer produces false out-of-date warnings, and analysis does not rewrite contexts to refresh metadata.

  • A safety copy and automatic migration when opening older projects, with progress when preparation takes time.
  • A newer unsupported format refuses opening and asks for an update.
  • Editing a context no longer accepts the companion file's changes; acknowledgment remains explicit.

Update Studio on every computer sharing a migrated project: 1.21 and earlier are not compatible with format 1.2. Read the format and migration details. Read about the Git release.

Completed in 1.21

Check that Studio works on your computer.

For this release I built a long battery of checks that drives the real application: what your AI does through MCP and HTTP, what you do in the window, and the files on disk afterwards. An installation can still fail because of something on your computer, so in 1.21 you can run those checks yourself, without an AI. On the Linux Snap they leave out the part that needs a browser.

Done in 1.21
  • An optional self-check you start from Help or the welcome screen, with a terminal entry also available in the Linux Snap. Before it starts it tells you what it will do; it works on artificial projects of its own and reopens yours when it ends.
  • Results that tell a failure apart from a cancelled, interrupted or incomplete check, explained once on the same screen.
  • If something fails, a ZIP report you can save and, if you want, send to support. It doesn’t include your projects, and Studio never uploads anything by itself.
  • The tree stays where you left it while you point at blocks in the editor. Click a block and the tree shows you where it lives; if its row is out of sight, a small hint at the edge of the tree tells you.

Studio 1.21 is available for Windows and Linux. Each recorded check covers its own platform and build. Read about the quality work in 1.21.

Completed in 1.20

A small, careful release.

  • Simpler setup guides: share AGENTS.md across most clients, including recent Claude Code versions. Update your Claude client and keep existing instructions as explained in the common guide.
  • Read a linked reference in a read-only area under the text you’re editing, without leaving it. The tree takes you somewhere; the center shows you.
  • A discreet notice in the document you have open when connected knowledge needs a review.
  • Shorter replies to your AI. Studio explains things once, then sticks to facts and exact commands, so fewer tokens go to repetition.
  • See what your AI receives when it opens a project: the exact text, piece by piece, with how much space each piece takes, so you can keep only the essentials there. How opening works.
  • Wording that fits a knowledge system rather than a code documentation tool, in all six languages: one word for each idea, from the app to the manual. Glossary.
  • A Learning Lab that teaches what changed since 1.15: following and reviewing relations, reading a reference without leaving your place, and checking what your AI receives, in all six languages.
  • Up to 20 outgoing relations per resource, sharing the same character budget: more links if they are concise, and your AI doesn’t read any more. I checked what AI coding agents accept before deciding. The relation counter.
  • Guides that say plainly who KaKeKiKoKu Studio is for: AI coding agents and the projects you build with them, code or not. Integrations.

The story behind it is in The tree takes you, the center shows you. Screenshots on this site and in the stores are refreshed when they need updating.