# TiXL (Tooll3): a realtime motion graphics toolkit with a node graph and keyframes

> TiXL is an MIT-licensed C# application for realtime motion graphics that mixes a procedural node graph with linear keyframe animation. It ships as a Windows executable, and the README points to a wiki for installation rather than giving steps inline.

**tixl3d/tixl** — TiXL is an open source software to create realtime motion graphics.

- Repository: https://github.com/tixl3d/tixl
- Website: https://tixl.app
- Stars: 5,122 · Forks: 274
- Language: C#
- License: MIT
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/tixl3d-tixl

## What TiXL solves, and who it is aimed at

TiXL is an open source application for creating realtime motion graphics. The README places it at what it calls the sweet spot between realtime rendering, graph-based procedural content generation, and linear keyframe animation and editing. Those three things usually live in separate tools: a node-based environment for generative visuals, and a timeline-based environment for hand-timed animation. TiXL's claim is that you can do both in one project, so a parameter can be driven procedurally and then overridden or blended with keyframes.

The README names three audiences. Artists use it to build audio reactive VJ content, to explore parameters through what the project calls advanced interfaces, and to combine keyframe animation with automation. Technical artists go deeper: fragment or compute shader development, MIDI controller input, sensors, OSC, and Spout. The project also states it can export small standalone executables, which matters if the output has to run on a machine without TiXL installed.

The framing is explicitly a work in progress. The README says version 4 is ongoing development, then immediately qualifies that it is stable enough to produce high-end visuals and to use industry standard features such as color correction, scopes and tone mapping. That is a candid description of a tool that is usable but still moving.

## The node graph, the operator set, and how a project is structured

The repository layout shows the shape of the application. Core/ holds the engine, Operators/ holds the node types, Editor/ and ImguiWindows/ hold the interface, and Serialization/ handles project files. There is a separate Player/ project, which corresponds to the standalone executable export the README mentions: the authoring application and the runtime that plays a composition back are different binaries.

The rendering stack is DirectX 11, which the repository topics confirm, with SilkWindows/ and SilkWindowTest/ indicating the windowing layer. ImguiWindows/ and the imgui topic point to an immediate-mode interface for the editor panels. MsForms/ and SystemUi/ suggest parts of the UI are built with Windows-native tooling rather than drawn in the render loop.

For anyone extending TiXL, the practical question is what operators already exist. The Operators/ directory is the place to look before writing anything new, because a graph is only as useful as its node library. Shader work is described in the README as fragment or compute shaders, so the shader path is a first-class part of the tool rather than an escape hatch.

Input and output are handled through named protocols. The README lists MIDI controllers, sensors, OSC and Spout. Spout is a Windows texture-sharing mechanism, which is consistent with the DirectX 11 and Windows focus of the whole project.

## Installing TiXL and running a first composition

The README does not contain installation steps. It links to an installation guide on the project wiki, and the repository also has an Installer/ directory and a release badge pointing at a versioned .exe download. The honest answer is that the install path is documented outside the README, so start there rather than guessing at build commands.

If you want to build from source instead, the repository has a solution file at the root. Opening it requires the .NET SDK version pinned in global.json, and the build properties live in Directory.Build.props, Directory.Build.targets and Tixl.props.

```bash
git clone https://github.com/tixl3d/tixl.git
cd tixl
dotnet build t3.sln
```

After the build, the editor binary is the one produced by the Editor/ project rather than the Player/ project. The Player/ project is what the standalone export uses.

There is one configuration file in the repository that is easy to misread. .env.example is not required to run the editor:

```bash
# Copy to `.env` and fill in. `.env` is gitignored.
SENTRY_AUTH_TOKEN=
SENTRY_ORG=tooll
SENTRY_PROJECT=tooll3
```

That file exists for the Sentry helper scripts, which the comments say need event:read to list issues and fetch event details, and event:write to mark issues resolved. The comment also notes that Sentry does not let you edit scopes after a token is created, so a token generated without event:write has to be replaced. For normal authoring work, ignore this file entirely.

Once the editor is open, the workflow the README describes is to build a graph, drive parameters, and layer keyframes on top where hand timing is needed. The README also points to a documentation wiki and a YouTube tutorial playlist, which is where the actual first-project walkthrough lives.

## Where TiXL is the wrong tool

The clearest limitation is platform. The repository topics name DirectX 11, the README's download badge points at a Windows .exe, and the windowing and UI directories lean on Windows tooling. Nothing in the README documents a macOS or Linux build. People search for TiXL on Mac and Linux, and the README does not answer those searches, which is itself the answer: there is no documented path.

The second limitation is maturity signalling. The README says version 4 is ongoing development. That is the project's own description, and it means the file format, operator behaviour, or interface can change between releases. The release history supports that reading: v4.3.0.2 arrived on 2026-09-21, a preview build v4.3.0.1 the day before, and a hotfix release v4.2.1 on 2026-08-04. A cadence with previews and hotfixes is normal for a tool under development, but it is not the cadence of something frozen.

The third limitation is more subtle. TiXL deliberately mixes a node graph with a keyframe timeline, and that combination is exactly what makes the mental model harder to learn than a pure node tool or a pure timeline tool. If your work is entirely procedural, the keyframe layer is overhead. If your work is entirely hand-animated, the graph is overhead. The README's own framing, that this is a balance the team experiments with, hints that the balance is still being tuned.

## TiXL compared with TouchDesigner

The comparison people actually search for is TiXL versus TouchDesigner, and the difference in approach is worth stating precisely. TouchDesigner is a commercial node-based environment; TiXL is MIT licensed and free, which removes the licensing question entirely for commercial work, subject to the terms in LICENSE.txt.

Structurally, the divergence is where keyframes sit. TouchDesigner's model is built around the operator network, with animation driven through channels and expressions. TiXL's README describes linear keyframe animation and editing as a peer to graph-based procedural content, not a layer bolted on top. Whether that matters depends on how much of your work is hand-timed. For an audio reactive VJ set, both approaches converge. For a piece where a designer wants to drag keyframes on a timeline and also branch into generative variation, TiXL's framing is aimed directly at that.

There is also a difference in the export story. The README states TiXL can export small standalone executables, and the Player/ project in the repository is the runtime for that. That is a specific capability, not a general one, and it is the kind of thing to verify against your own deployment target before assuming it fits.

## Maintenance, licensing, and what upgrades cost

The repository is not archived, and the last push was on 2026-09-22, one day before the current release v4.3.0.2. That is a project being worked on now, not a dormant one. The release naming is worth reading carefully when you upgrade: v4.3.0.1 is labelled preview, while v4.3.0.2 and the earlier v4.2.1 are not. If you are running TiXL in production, the preview label is the signal to skip that build.

Upgrade cost is not documented in the README. There is a ProjectUpdater/ directory in the repository, which indicates the project has some mechanism for bringing older project files forward, but the README does not describe it and does not document rollback. That is a real gap: if a new release changes how a composition loads, the README gives no stated procedure for reverting. Test an upgrade against a copy of a project before opening the only copy.

The licence is MIT, per the README badge and LICENSE.txt. MIT is permissive: it allows commercial use and modification, and it requires preserving the copyright notice and licence text. That is a plain statement of what the licence is, not legal advice. If you redistribute TiXL or a build derived from it, read LICENSE.txt rather than relying on the badge. Note also that Dependencies/ and Vendor/ exist in the repository, and third-party components bundled there may carry their own terms.

## Conclusion

TiXL fits artists and technical artists on Windows who want a node graph and keyframe timeline in the same tool, and who accept that v4 is described in the README as ongoing development. It is the wrong choice if you need a documented macOS or Linux build today, since the README covers neither. Before committing, open the wiki installation guide, confirm the current release on the repository's releases page, and check whether the operator set you need exists in the Operators/ directory. The .env.example file is only relevant if you plan to run the Sentry helper scripts, not for normal use of the editor.

## FAQ

### What is TiXL software?

TiXL, also called Tooll3, is an open source application for creating realtime motion graphics. The README describes it as targeting the combination of realtime rendering, graph-based procedural content generation, and linear keyframe animation and editing.

### How do I install TiXL?

The README does not list install steps. It links to an installation guide on the project wiki, and the repository also contains an Installer/ directory and a release badge pointing at a versioned .exe download.

### Does TiXL run on macOS or Linux?

The README does not document either. The repository topics name DirectX 11, the README's download badge points at a Windows .exe, and the README mentions no macOS or Linux build.

### Is TiXL free to use?

TiXL is MIT licensed, as shown by the README badge and LICENSE.txt. MIT permits commercial use and modification and requires preserving the copyright notice and licence text.

### What can I connect TiXL to?

The README lists MIDI controllers, sensors, OSC and Spout as inputs and outputs. It also mentions fragment and compute shader development for technical artists.

### Can TiXL export a standalone file?

The README states TiXL can export small standalone executables. The repository has a separate Player/ project, which corresponds to the runtime used for playback rather than authoring.

## Sources

- [License: MIT](https://github.com/tixl3d/tixl/blob/main/LICENSE)
- [Project website](https://tixl.app)
- [README](https://github.com/tixl3d/tixl/blob/main/README.md)
- [Releases](https://github.com/tixl3d/tixl/releases)
- [tixl3d/tixl on GitHub](https://github.com/tixl3d/tixl)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tixl3d-tixl