truncate.town

Truncate's client and server source code is published on GitHub at TruncateGame/Truncate, and the game's credits page lists its contributing artists, audio and font assets, open-source dependencies, and word data sources. Both the code and the credits are reachable from the game's own site, truncate.town.

Source Code on GitHub

The credits section of truncate.town states that "Truncate's client and server are both available as open-source code on GitHub at TruncateGame/Truncate." That single repository covers both halves of the game:

If you are looking for the code rather than the credits, the repository is the entry point — the site itself does not host a separate download page for the source.

What the Credits Page Covers

The credits section on truncate.town is organized under five headings, each naming the people or projects behind a part of the game:

• Contributing artists — Joree is credited for art contributions.
• Audio assets — the puzzle-piece placement sound is credited to el_boss under CC0 1.0.
• Font assets — Press Start 2P by codeman38 under the OFL, and at01 by GrafxKid under CC0 1.0.
• Notable open-source dependencies — egui by Emil Ernerfeldt under MIT, plus all dependencies in the Truncate repository.
• Word data sources — SCOWL Wordlist by Kevin Atkinson (MIT-like), Wordnik Wordlist by Wordnik (MIT), Wiktionary (CC BY-SA 3.0), and Wiktextract by Tatu Ylonen / Kaikki.org (CC BY-SA 3.0).

Truncate itself is credited to its creators, Liam Bigelow and Blake McAlevey-Scurr.

Reusing Assets: Check the License First

The credits page is also where reuse permissions are stated, and they are not uniform:

• Sprites are described as available to use under a CC BY-SA 4.0 license.
• Audio and fonts carry their own licenses (CC0 1.0 and OFL respectively), which apply to those assets rather than to the game as a whole.
• Word lists come from four separate sources with three different license families, so a word list you want to reuse should be traced back to its specific source.

A practical rule: before republishing any Truncate asset, match it to the license named next to it in the credits rather than assuming one license covers everything. For example, if you plan to ship the sprite set inside your own project, the CC BY-SA 4.0 terms apply to those sprites, while the egui dependency remains under MIT.

Quick Reference

• Repository: TruncateGame/Truncate on GitHub (client and server).
• Credits: the "Updates & Credits" section of truncate.town.
• Creators: Liam Bigelow and Blake McAlevey-Scurr.
• Sprite license: CC BY-SA 4.0.
• Dependencies: egui (MIT) plus the repository's own dependency list.

The site does not publish pricing or account requirements for the game, so treat the GitHub repository and the credits page as the two confirmed resource entry points.

An open-source UI element library is a collection of individual, ready-made interface pieces—buttons, cards, inputs, toggles, loaders—that you copy into your own project and adapt. A UI framework, by contrast, is a structured system of components, conventions, and often a theming layer that governs how your whole interface is built. The practical difference: an element library gives you a snippet; a framework gives you a way of working. If you need a polished button in ten minutes, reach for the element library. If you're building a 40-screen product with a team, you probably want the framework.

What "open-source UI element library" actually means

The term gets used loosely, so it helps to separate the parts:

• Open-source: the code is publicly available, and the license tells you what you may do with it—copy, modify, redistribute, or use commercially.
• UI element: a single, self-contained piece of interface, usually small enough to read in one sitting. A button with hover states, a pricing card, a search field.
• Library: a browsable, searchable collection of those elements, typically contributed by many different people.

On a site like Uiverse, elements are shared by a community and written in plain CSS or Tailwind. You find one you like, copy the markup and styles, paste them into your project, and adjust colors, spacing, and text to fit. There's no package to install and no build step required—which is exactly the appeal, and also the source of most of the confusion.

Element library vs. UI framework: the core differences

The table isn't a verdict. It's a map of trade-offs. Element libraries win on speed and freedom; frameworks win on consistency and maintenance.

Licensing and attribution: what to check before you paste

This is where people get into trouble, and it's worth slowing down for.

1. Find the license. Every element or collection should state one. Common open-source licenses include MIT, Apache-2.0, and BSD. Some projects use copyleft licenses like GPL, which can impose obligations if you redistribute your code.
2. Understand what the license permits. MIT and Apache-2.0 are permissive: you can typically use the code in commercial and closed-source projects. Copyleft licenses may require you to release derivative source under the same terms.
3. Check attribution requirements. Permissive licenses usually require you to keep the copyright notice and license text somewhere in your project. That's a real obligation, not a formality.
4. Look for per-element terms. On community sites, the site's overall terms and the individual contributor's stated wishes may differ. If a contributor asks for credit, honor it.
5. When in doubt, ask or avoid. If a snippet has no license at all, you don't have clear permission to reuse it. Treat "no license" as "not open source," even if the code is publicly visible.

This article is general information, not legal advice. For commercial products with real exposure, have someone qualified review the licenses you're relying on.

How to use a community element in your project: a practical workflow

Here's a repeatable process that avoids most of the usual mess.

1. Start from a real need, not a browsing session

Decide what you need first—"a compact primary button with a loading state"—then search. Browsing aimlessly produces a pile of pretty snippets that don't fit together.

2. Copy the smallest version that works

Take the markup and the styles. Strip anything you don't need: demo wrappers, extra animations, decorative layers. Less code means fewer surprises.

3. Convert it to your conventions

If your project uses design tokens or CSS variables, replace hard-coded values:

/* Before: hard-coded */
.button { background: #4f46e5; border-radius: 8px; }

/* After: token-based */
.button { background: var(--color-primary); border-radius: var(--radius-md); }

This one step is what keeps a copied element from looking like a foreign object in your UI.

4. Check accessibility before you ship

Community elements vary widely here. Verify at minimum:

• Keyboard focus is visible and the element is reachable by Tab.
• Color contrast meets WCAG AA (4.5:1 for normal text).
• Interactive elements use semantic HTML (<button>, not a clickable <div>).
• Form inputs have associated labels.
• Motion respects prefers-reduced-motion.

5. Test in context

Paste it into a real page with real content. Long labels, small screens, and dark mode break more copied elements than anything else.

6. Note where it came from

Keep a short comment or an internal credits file: source, license, date. Future you—and your legal reviewer—will be grateful.

Where element libraries genuinely shine

• Prototypes and demos: you need something clickable today, not a design system.
• Landing pages and marketing sites: a handful of distinctive elements, each custom.
• Filling gaps: your framework lacks one specific component, and you don't want to build it from scratch.
• Learning: reading well-made CSS is one of the fastest ways to improve.
• Small projects: a personal site doesn't need a theming architecture.

Where they fall short

• Consistency at scale: ten elements from ten contributors rarely look like one product.
• Maintenance: you own every copy. When your design changes, you edit each one.
• Accessibility debt: you inherit whatever the contributor did or didn't do.
• No upstream fixes: a bug fixed in the original won't reach your copy.
• Integration friction: different naming conventions, different units, different assumptions about resets.

When to choose which

Choose an element library when the scope is small, the timeline is short, or you need a few distinctive pieces rather than a whole system.

Choose a framework or design system when multiple people build multiple screens over months, when consistency is a product requirement, or when accessibility and theming need to be guaranteed rather than checked.

A hybrid works well for many teams: adopt a framework for the structural components—forms, navigation, layout—and borrow individual elements for the places where you want personality. Just route every borrowed element through the same token and accessibility checks, so it lands as part of your system rather than beside it.

The short version: open-source UI element libraries are a fast, flexible way to get good-looking interface pieces into a project. They are not a substitute for a design system, and the license and accessibility details are the part worth reading carefully.

Truncate is a word-based strategy game in which players spell words to cut off their opponent and conquer their town. The site at truncate.town is the game's page, and it also carries an updates-and-credits section. Truncate was created by Liam Bigelow and Blake McAlevey-Scurr, and both its client and server are available as open-source code on GitHub at TruncateGame/Truncate.

What the site offers

The page is organized around the game itself plus a credits area. The credits section thanks the people and projects behind the game's art, audio, fonts, open-source dependencies, and word data. If you want to know what the game is built on or who contributed to it, that section is the place to look.

The game in one line

The core idea is competitive word spelling with a territorial goal: spell words to cut off your enemy and take over their town. That description comes straight from the site's own summary of the game.

Open source and licensing

Because the client and server are both open source, you can inspect the code or see how the game is put together rather than only playing it.

Credits worth knowing

The credits list several asset and data sources, which is useful if you care about provenance or want to reuse components under their terms:

• Art: contributing artist Joree.
• Audio: the puzzle-piece-placed-on-board sound by el_boss, under CC0 1.0.
• Fonts: Press Start 2P by codeman38 under OFL, and at01 by GrafxKid under CC0 1.0.
• Notable open-source dependencies: egui by Emil Ernerfeldt under MIT, plus all dependencies in the Truncate repository.
• Word data: the SCOWL Wordlist by Kevin Atkinson (MIT-like), the Wordnik Wordlist by Wordnik (MIT), Wiktionary (CC BY-SA 3.0), and Wiktextract by Tatu Ylonen / Kaikki.org (CC BY-SA 3.0).

Who this is for

If you are looking for a word game with a strategic, head-to-head twist, Truncate is the game to try. If you are a developer or designer, the open-source repository and the credited asset licenses give you a way to study or build on the project. The site itself does not publish pricing or account details, so check the game page directly for how to play.

Truncate draws its word data from four sources: the SCOWL Wordlist (MIT-like license), the Wordnik Wordlist (MIT), Wiktionary (CC BY-SA 3.0), and Wiktextract, a machine-readable Wiktionary extract by Tatu Ylonen / Kaikki.org (CC BY-SA 3.0). Its visual, audio, and font assets come from named contributors under CC0, CC BY-SA 4.0, and OFL licenses. The credits page lists all of these, and the game's client and server code is open source on GitHub.

Word Data Sources

The credits page names four word data sources. They differ in origin and license, which matters if you plan to reuse anything.

The two Wiktionary-derived sources carry share-alike terms, so any reuse of that data should keep the same license and attribution. The SCOWL and Wordnik lists are more permissive.

Art, Audio, and Fonts

The credits page separates assets by type and names each contributor.

• Sprites: available under CC BY-SA 4.0. Contributing artist: Joree.
• Audio: the puzzle-piece placement sound is by el_boss under CC0 1.0.
• Fonts: Press Start 2P by codeman38 under OFL, and at01 by GrafxKid under CC0 1.0.

If you want to reuse the look of the game, the sprite license is the one to check first, since CC BY-SA 4.0 requires attribution and share-alike.

Code and Dependencies

Truncate's client and server are both open source at GitHub (TruncateGame/Truncate). The credits note one notable dependency, egui by Emil Ernerfeldt under MIT, plus all other dependencies in the repository. For a full dependency list, the repository itself is the authoritative place to look.

What This Means If You Want to Reuse Something

• Word lists: SCOWL and Wordnik are the simplest to reuse; Wiktionary-based data carries CC BY-SA 3.0 obligations.
• Sprites: CC BY-SA 4.0 — attribute the artist and keep the same license.
• Audio and the at01 font: CC0, so no attribution is required, though crediting is still good practice.
• Press Start 2P: OFL, which permits use and embedding under its terms.
• Code: check the repository for the license covering the client and server before building on it.

The credits page is the single place that ties each asset to its creator and license, so it is the right starting point for any reuse question.

Truncate is a word-based strategy game in which you spell words to cut off enemy territory and conquer their town. It is not a spelling contest or a crossword: the words are moves on a shared board, and the goal is positional — take the opponent's town, not simply score the longest word. The description on truncate.town frames the whole game in one line: "Spell words to cut off your enemy and conquer their town."

The Core Idea

Each turn, you form a word from the available letters. That word does something to the board — specifically, it cuts territory. The cut is the strategy: you are trying to separate the enemy from space, resources, or their town, while keeping your own position connected.

This is why the game sits closer to a strategy game than a word game. A long, obscure word is only good if the cut it produces helps you. A short, common word placed well can be stronger than a showy one.

What "truncate" means in play

The name is the mechanic. To truncate is to cut short — and in this game, your word truncates the enemy's holdings. Think of the board as a map divided between two sides; a well-placed word severs a chunk of that map from the enemy's town. Once a section is cut off, it is no longer useful to them.

For example, if the enemy's town sits at one edge and their territory stretches toward the middle, a word that draws a line across that stretch can strand everything beyond it. The enemy keeps the letters they can still reach, but the severed area stops helping them.

How a Game Plays Out

The general loop is:

1. Read the board. Look at where the enemy town is, where your town is, and how territory connects them.
2. Find a word that cuts, not just a word that scores. Ask what the word separates.
3. Spell it. The word is placed and the cut takes effect.
4. The opponent responds with a word of their own, trying to cut you or reconnect.
5. Repeat until one town is taken.

The win condition is conquest of the enemy town, so every cut should move you toward that or defend against it. A cut that strands a large area but leaves your own town exposed is usually a bad trade.

Reading the board before you spell

Two questions decide most moves:

• Does this word cut something that matters? Severing empty space achieves little; severing the path to the town matters.
• Does it leave me open? If your word opens a lane toward your own town, the opponent can use it next turn.

Because both players are cutting, the board shrinks in usefulness over time. Early moves shape the map; late moves are about finishing the conquest.

What Kind of Game It Is — and Isn't

If you enjoy word games but find yourself optimizing for big words, Truncate asks you to optimize for position instead. If you enjoy strategy games but not vocabulary, the word list is broad — the game draws on large public word sources — so the challenge is usually finding the right cut, not the most obscure word.

Practical Notes

• The game is open source. The client and server code are published on GitHub at TruncateGame/Truncate, so you can inspect how it works or run it yourself if you have the technical setup.
• The art is reusable. Truncate's sprites are available under a CC BY-SA 4.0 license.
• It was made by two developers, Liam Bigelow and Blake McAlevey-Scurr, and credits a set of contributing artists, audio and font assets, and word data sources including SCOWL, Wordnik, Wiktionary, and Wiktextract.

The site does not state pricing or login requirements, so check truncate.town directly for how to play and whether an account is needed.

The Short Version

Truncate works like this: spell a word, cut the enemy's territory with it, and keep cutting until you take their town. The word is the weapon; the map is the game. Play for position, protect your own town, and treat every spelling choice as a strategic move rather than a vocabulary display.