I mentioned fast hot reload because your original comment complained about compilation speed, and some people might not know you were referring to the speed of compiling your custom Luau integration in C++ (which is also fast for me, personally).
Sounds like the Discord I mentioned is technically the Roblox discord. The #luau-lang and #luau-lsp channels are where I lurk.
I use Luau with my Unity game for all gameplay code (60k+ loc so far). I agree the docs could be improved, especially for custom integrations. The new type system + LSP aren't great together yet either, and I've been a little worried about the direction since zeux left the team.
But otherwise I really like it. My Luau code hot reloads almost instantly while the game is running, and my C++ project compiles quickly when I update it. I like that it provides sandboxing if you want to support modding. And there's an active community of people on the official Discord, which is better than nothing.
Some friends of mine played Descent competitively, and I was amazed to learn about so-called trichording: to maximize your speed, you need to press multiple keys at the same time to travel along all 3 axes at once, e.g. forward/right/up. The best players zip around the map diagonally.
I always assumed this was a bug-turned-feature, like skiing in Tribes. When I saw the repo just now, I looked for clues, but didn't spot any related comments around the line of code where this ultimately happens:
I use Luau in my games and tools [1], and I recommend it. While I can't speak to transitioning to it from Lua, since I didn't do that, I can say that it's fast, stable, sandboxing just works (important for your use case), and it's very well supported and regularly updated.
For context, I first started using Luau as an experimental hack by integrating it with Unity. I mostly just wanted fast and simple hot reloading. I found myself writing more and more of it, and now I'm writing most of my code in it.
VS Code support is pretty good via the luau-lsp language server [2]. Type support for certain code patterns isn't great yet, but there are RFCs to improve this.
They're also quietly working on native code gen and JIT support, e.g. this PR from a few hours ago [3].
Finger snapping is fascinating too. I always assumed the sound happens when your finger rubs quickly against your thumb. But it’s actually after that, when your finger strikes the fleshy part of your thumb. You can verify this by blocking your finger from striking your hand.
So it’s actually more like finger clapping. The “snap” part just lets you build energy for the “clap” part. Maybe obvious to some but I amazingly only learned this later in life.
My emotional journey with Val having just learned about it today:
Oh neat, a new systems language, probably nothing but let's take a peek. Docs look legit. Hmm some thoughtful ideas in here around ownership. Syntax makes sense. But is it different enough to justify its own existence? Who makes it?
Oooh, Dave Abrahams is working on it. We crossed paths at Apple and I remember his Crusty talk about Swift [1]. It was great, loved the strong opinions, but Apple sadly removed it years later because it had some outdated advice. Wait, he's at Adobe now? So is this an Adobe language?
Conclusion: keep an eye on it, will watch the linked talks, wait and see.
A friend of mine is making a new city-builder called Metropolis 1998 [1]. If you're into SimCity 2000 specifics, you might also enjoy his dev updates where he posts about his pixel graphics engine, custom pathfinding for agents/cars, etc.
When I started making a game [0] last year, first thing I did was write a little Unity script that takes a screenshot of the opening scene, counts current lines of code using CLOC [1] (for fun, not as a true measure of anything), and occasionally renders it all out to an image file.
With that I'm able to create some pretty fun time lapses of progress. I've been doing this at an arbitrary milestone, whenever my Luau [2] LOC surpasses C++ by another factor. This post reminded me I'm overdue for another now that Luau > 3x C++ LOC.
I find it rewarding to look back at my progress. I'll share in case it's interesting for you too [3].
The most remarkable thing about "Bret Victor's vision" is how different people have interpreted what his vision even is. His ideas are multi-faceted, so they inspire in several important directions all at once, e.g.:
- direct manipulation (an old idea but beautifully captured in his projects)
- making logic feel more geometric / concrete
- visualizing and manipulating data, especially over time
- humane interfaces (putting "computing" into the world around us, but without AR)
- etc.
Bret Victor is very much Alan Kay's protege and has unfortunately inherited the curse of people cherry-picking particular ideas and missing the bigger picture.
So as others have pointed out, the only person who may be fully attempting Bret Victor's vision is Bret Victor with Dynamicland. You may also be curious to check out Humane [1] which is a hardware startup founded by ex-Apple people. They're rumored to be shipping a projection-based wearable device this year. This device could potentially be a platform for people to experiment more in the direction of Bret Victor's vision.
The area I think is most exciting (and in need of more innovation) is using natural language to create (and modify!) the actual simulation / rules / behaviors. Our approach was to map language outputs to actions that could be chained together using Goal Oriented Action Planning plus an Entity Component System. The user's verbs / prepositions / etc. would add layers of goals, each of which would enable or disable certain behavior components when triggered.
As others have mentioned, "making software programmable" isn't really landing for me.
In the tradition of borrowing terms from the games industry (where we often see early popularization of good ideas), I wonder if "modding" could be a helpful addition somewhere in your marketing.
This seems to have worked for the term "multiplayer", though "moddable" probably isn't as widely appreciated yet.
The makers of Dion now work at Epic. My guess is they're contributing to Verse [0], a new programming language (environment?) being worked on at Epic, which could be of interest to people in this thread.
Verse is believed to include ideas from SkookumScript, which Epic acquired [1], and Simon Peyton Jones, a main contributor to Haskell [2].
JetBrains MPS [0] is worth a look for inspiration. Like some of the other projects mentioned here, it's an editor on top of an Abstract Syntax Tree. You can use it to make DSLs that have different UI/UX projections.
I'm not sure anyone's actually using it, but there are some good ideas in there.
It does get lonely. I'm a former YC founder and I left Apple earlier this year to be a solo game dev. Making games (compared to apps or tools) is especially hard because "fun" is so nebulous that "make something people want" is a blurry goal at best.
I also work on my own tools and I'm using them to build the game. I'm very interested in tools that help a very small but talented team (1-4 people) build ambitious games more successfully.
> has anyone even proposed an "engine agnostic" IDE experience for game dev?
I'm working in this direction. My focus is on higher-level editors for making worlds, meshes, animations, sounds, and visual effects. So far it's mostly written in Luau (Roblox's open source version of Lua) and the first engine integration is Unity. You use the editors and a Luau API to make your game. The API for now is part Unity-inspired and part Roblox-inspired.
I have the editors and Luau integration working well enough that I'm now using them to build a game. I plan to do that before supporting other engines. I've been building with other engines in mind (including having an abstraction), but I wanted to prove (to myself at least) that the editors have value before going down this path.
I'm kind of taking some risks with the editors, e.g. they're diegetic (all in-world UI). My main goal is to build higher-level editors that are actually fun to use, and then supporting multiple engines is secondary. Good to know someone else is thinking about that though!
Very interesting. Like the sibling comment, I'm also curious about your API for this.
I've been using Unity in a similar way but with Luau (a gradually typed Lua by Roblox) for the API. It's been very educational to treat Unity as a box like this, and I've been making the Luau API very high-level, often following Roblox patterns (more coarsely grained).
As a side-effect of this separation, it's also refreshing to have the option to make everything work with other engines.
Sounds like the Discord I mentioned is technically the Roblox discord. The #luau-lang and #luau-lsp channels are where I lurk.