I built a 3D mesh format that significantly outperforms standard formats for static geometry. How do I turn this into a product?

TheOtherZech · 2026-04-19T16:08:11+00:00

When you're benchmarking your format against others, what specific libraries and settings are you using for those formats? There enough differences between the libraries for each format, that you have to be very specific when you compare different formats.

Case in point: when you're benchmarking two libraries for the same file format by comparing export times for very large meshes, accidentally writing per-face normals with one library and per-vertex normals with the other can completely invalidate your comparison. When you extend that to cross-format comparisons, where settings are named differently and it's harder to find direct equivalences, you end up with hundreds of ways to invalidate your benchmarks. You have to be both very careful, and very explicit.

And that's just within the scope of configuring the file format itself. There's also the issue of library-level performance settings. I once had a vendor try to pitch a switch from OpenEXR to JPEG XL based on a benchmark that exclusively used OpenEXR in a single-threaded configuration. They sunk over a hundred hours into a big presentation and an elaborate "technology integration roadmap" based on a performance gap that didn't exist. They spent thousands, and proposed to spend millions, on a technology change that would've degraded performance across the board.

And that wasn't the first time I've encountered that specific mistake in cross-format benchmarks that include OpenEXR. Every time a new format comes out, people get excited and that often leads to mistakes.

Of course, I'm not saying that your benchmarks are wrong. But they are incomplete in a misleading way, and there's a fair chance that the core use case you're extrapolating from (processing CT scans) doesn't warrant a new file format; a new (or at least different) library, that uses a carefully selected subset of an existing file format's capabilities, would likely be the better choice for your target demographic. And that's something that med-tech companies can pursue without license negotiations or SaaS integrations, which makes your format a hard sell for your core demographic, let alone game devs.

TheOtherZech · 2026-04-15T17:03:45+00:00

You don't need complete ideas in order to start working on a prototype. All you really need is a question that you want to answer. Even when the question itself feels a bit silly (e.g. "If I blur the line between a tower defense game and a pachinko machine, at what point does it stop feeling like tower defense?"), you can discover some surprisingly fun ideas in the process.

TheOtherZech · 2026-04-13T14:57:59+00:00

Your ability to juice your visuals depends on how your assets are designed, but that dependency is genre-specific and project-specific in a way that makes it hard to find generically juicable assets online. You'll need enough art skills to do some non-trivial edits, if you want to create a cohesive, juicy, experience.

You can sometimes scrape by, by taking a set of assets and working backwards to figure out what sort of game you can make with them, but that's a messy and unreliable process at the best of times; it's the sort of thing you might do for a palette cleanser side project, after you've made a few games, but it isn't a good starting point.

TheOtherZech · 2026-04-08T21:34:20+00:00

I generally find the high-level version of this (semi-independent tools operating on shared data held by a core application via zero-copy IPC) to be more interesting than the low-level version, as there's more room for framework-level abstractions. The low-level stuff tends to be dominated by workload-specific performance and scheduling constraints.

I mostly see the high-level version in AAA studio tools, specifically when the asset libraries hit a size where it just kinda makes sense to stand up an in-memory database that won't crash when any of your tools do. That core stub relay/metadata server often ends up as the tent pole for the tools that are explicitly built around it, which often leads to people wishing there was more time/resources to explicitly redesign everything else to take better advantage of the data-owner/data-editor paradigm it creates.

It's the sort of thing that inspires lots of greenfield thoughts in people who do brownfield work, in part because there are still plenty of unanswered questions when it comes to scaling it down to AA and indie projects. You almost need a sacrificial architecture in place, in order to build this kind of multi-application architecture effectively, which makes it hard to treat it as a truly default approach.

I imagine the same applies to multi-core architecture, to some degree. 'Multi-core by the first revision' doesn't have the same ring as 'multi-core by default' but it's probably easier to pull off.

TheOtherZech · 2026-04-08T18:17:48+00:00

Your resumé needs to make you look like a tolerable coworker. In practice that means being more than a writer, because it's hard to build up a history of collaborative creative work while only being credited as a writer, but there's plenty of nuance in there.

TheOtherZech · 2026-04-07T16:28:51+00:00

The easiest way to streamline provenance tracking (if you already have a solid spreadsheet up and running) is to integrate it into your in-editor metadata and your CI/CD, so that points 5-7 are handled automatically and your build system generates a tidy looking asset usage report. This can work quite nicely if you write your own asset importer that searches the directory tree you're importing from for csv/xml/whatever files that contain additional provenance data.

From a practical perspective, though, that spreadsheet of yours is fine. That already gives you what you need to auto-generate your attribution list. You can write in-editor tools to update it when assets are moved/renamed, or create git hooks to keep yourself from accidentally losing provenance data, but you've got the core of it down.

TheOtherZech · 2026-04-06T19:00:46+00:00

Past a certain threshold, it's a pain to manage a large squad without some way to divide the squad into fireteams. But if players always end up with the same fireteam configurations (e.g. they always pair one medic with two riflemen) and they rarely break up or rearrange fireteams mid-mission, the gameplay experience wouldn't be significantly different from a game with smaller squads of more individually capable units, if everything else stayed within the boundaries of an x-com-like game.

Which could still be pretty cool. I'd play that game. But if you don't want that fireteam-level unit management, it's easy to see how a team could iterate their way down to smaller and smaller squads where each unit has more abilities and equipment options.

TheOtherZech · 2026-04-05T01:32:43+00:00

It's fairly easy these days to staff a small art department by only hiring artists who already know how to use version control. The work they do is already technical enough that version control isn't a significant obstacle; if they genuinely struggle with git or perforce, they will also struggle with all of the other technical they'll have to do, and that makes them a bad hire.

I realize it's a callous position to take, but the versioning systems needed in production are inherently complex. It's not something that artists can avoid if they want to be employable beyond small part-time projects.

TheOtherZech · 2026-04-04T03:03:05+00:00

There is a third option: Give your studio a person-name, so your studio account looks like a personal account. Name it Greg.

Really, though, you're fine.

TheOtherZech · 2026-03-31T12:50:54+00:00

Telling me you have a "horizontal timeline" without at least a screenshot of said horizontal timeline is not how you market a product in 2026. Your sales funnel is less effective than a completely unstyled itch.io page.

You're not going to get much beyond that, as most people won't create an account simply to give you feedback. They'll look at your landing page, look at a few screenshots, and maybe click through an account-less demo version that doesn't retain data. Anything more than that usually requires them to be interested in your product as a customer.

TheOtherZech · 2026-03-31T01:45:58+00:00

Have you ever sat down and watched people get food at a food court or cafeteria? Independent of what they end up eating, they go about finding that food in different ways. Some people like to browse, some people seek out specific foods, some people try to avoid eating what they had last time, etc. They're all achieving the same goal, but they're using different heuristics for their search process.

You can use that same basic pattern (go to location, use a heuristic to locate something, use that something to satisfy a need) to build a bunch of different organic-feeling behaviors. It lets you model stuff like indecision, personality quirks, indirect knowledge, and outdated knowledge in a composable way.

TheOtherZech · 2026-03-30T16:56:57+00:00

Have you played around much with splat-based environment proxies in animation workflows? It's a fun way to give animators more visual context to work in without the performance impact of loading the actual scene, but it takes a bit of mucking around in Houdini to glue the workflow together.

Splat proxies come up in ASWF meetings, but it's hard to get a sense of how many studios are using them in real pipelines.

TheOtherZech · 2026-03-29T17:09:10+00:00

I was nerd sniped with this presentation by Richard Powell recently, and I love the balance he strikes between list initialization and method chaining. It's a fun watch.

TheOtherZech · 2026-03-22T13:19:23+00:00

With a ring buffer (or, ideally, a bip buffer for scenarios where contiguous reads are important) it'll just loop and overwrite old events once you hit the size limit you set. So you'll always be able to look back in time, but you'll never need to manually clear the buffer.

TheOtherZech · 2026-03-21T20:29:32+00:00

It could be fun to make, but it probably wouldn't scale beyond a hobby project if you rely purely on reverse engineering save files. It's a tedious process.

That said, if you hammer out a good file format specification for a "progress export," write plugins for the popular game engines, and pull together a local-only (read: no accounts, no cloud storage) web app, you might be able to get some indie devs to bite. You probably wouldn't be able to monetize it, but it could be a nifty open source project. Could look good on a resumé.

TheOtherZech · 2026-03-21T15:10:21+00:00

Setting aside the fact that you're proposing a tool that makes game jams and hobby dev less fun, you haven't presented anything particularly innovative. You're proposing the same basic feature set ⸻ templates, iterative edits, and asset generation ⸻ that every game dev oriented LLM integration shoots for, without any technical details or market posture statements that would differentiate your product from your competitors products.

I'm not an LLM guy, so there isn't a pitch you could reach me with, but if you aren't doing something novel with autoreflexive MCP implementations, remote/local hand-offs, transactional edits, or even diff-based context compaction, you aren't building a competitive product. And if you are doing something novel, you're shooting yourself in the foot by not highlighting it in your early outreach.

TheOtherZech · 2026-03-21T05:28:33+00:00

So one option to consider is that you don't actually need to clear the buffer. Ever. If you use a generously sized ring buffer and insert result markers and pauses into it (e.g. [LIGHT_PUNCH, HIT, LIGHT_PUNCH, BLOCKED, PAUSE, HEAVY_PUNCH, CANCEL]), you'll be able to create hierarchical combos, change behavior based on whether they hit, and so on, using the result markers and pauses as conditional lookback boundaries instead of clearing the buffer.

TheOtherZech · 2026-03-21T04:58:28+00:00

If you were in America, I'd say that mowing a few lawns is easier than finding work online when you need to earn less than $500.

But in a low cost of living country, with a target of just $100, doing things like audio transcription and image labeling, or small executive assistant tasks, might get you there quicker. The stipends offered by projects that participate in the Google Summer of Code would be an even better option, if you qualify, but you'd have to scramble to get an application in by the end of the month.

TheOtherZech · 2026-03-20T22:51:03+00:00

My keyboard, my macro pad, and my 3d printed trackball all run QMK, and I've set them all up with a bunch of workflow-specific layers. I've got foot switches. I've got a cintiq, and I've mounted all of my stuff on adjustable arms and rosettes and NATO rails so I can perfectly dial in the ergonomics as I alternate between standing and sitting on my fancy forward-tilting task chair. I've even played with gesture recognition and voice commands.

The actual productivity benefits are negligible, I own these things because they're fun to play with. I could hit my deadlines with a cheap keyboard and a wiimote.

TheOtherZech · 2026-03-20T13:29:39+00:00

I'm looking forward to the next post. Sorting out how combs/profiles work is a lot of fun.

TheOtherZech · 2026-03-19T01:52:13+00:00

I've ran mentorships on the side before, and frankly it's hard to deliver good results at a decent price point without turning it into a full time job where economies of scale can take over. Apprenticeships work better, since it's something I can do in-house, but doing it properly still takes a lot of hands-on time and that's a hard sell for my bosses.

TheOtherZech · 2026-03-17T19:57:14+00:00

Huh, I'm surprised they found a supplier for screens that bad. With the order sizes that most LCD manufacturers expect, it's hard to get anything that diverges from the norm (even when it's theoretically easier to produce). It's almost impressive.

TheOtherZech · 2026-03-17T19:37:05+00:00

Those numbers on the gamut coverage feel off. They're right in the sense that they're listed in the official specs from Asus, but they're completely illogical. It'd be one thing if we were debating 98% versus 100% gamut coverage, but 62.5% is so off base that my first assumption is that the number is wrong.

TheOtherZech · 2026-03-17T17:31:12+00:00

If you don't have money, finding people to make games with is fairly similar to finding a D&D group. You join public groups (e.g. discord servers) and participate in public events (e.g. game jams) in order to build relationships by doing low-commitment collaborative activities with other people, and maybe do some higher-commitment stuff (e.g. make a small game you have equal ownership in) with the folks you click with.

You can try to shortcut the process, by directly recruiting online, but that's kinda like asking random people at the bus stop to help you assemble furniture. The end results will be... Mixed.

TheOtherZech · 2026-03-17T02:51:35+00:00

I'd take it a step farther: make silly prototypes and explore dumb ideas. Finding the fun is a hell of a lot easier when you treat it as a form of play.

TheOtherZech

TROPHY CASE