The demo is out, give it a try!
When the Stars Threw Down Their Spears is a retro space shooter with gameplay inspired by DOS-era space games, and a story inspired by the collapse of the Roman Republic in the first century B.C.E. Blast your way through fast-paced arcade combat; build out modular, upgradable ships; explore a galaxy torn by war; and decide the fate of a fragile republic fighting for its life.
I was really trying to do everything myself and be truly solo on this project, but I got a lot of (justifiably) negative feedback about my home-made capsule art (the second image). The last straw was when someone looked at it and asked if I was "really going to go with that?" After that, I swallowed my pride and hired a friend who is an illustrator, and she did an incredible job (the first image). Now I feel kind of dumb for not doing this a lot sooner.
Have you had a similar moment where you realized it was time to hire someone? What was the tipping point for you?
A month or two back I posted on this sub about how great emacs was for game development with Godot. There were a bunch of questions in the comments about my configuration and workflow for getting emacs and Godot to work together. I tried to answer questions in them comments, but several folks wanted more specific details, so I thought I'd do a longer post with some config snippets and tips on how I've been using emacs and Godot to make a game.
I basically live in emacs, so my goal was to push as much of my workflow as possible out of Godot and into emacs. Below I'll address emacs configuration, godot-side configuration, and my day-to-day workflow.
A disclaimer: I'm not a professional game developer by any stretch of the imagination. I'm a hobbyist, so take my advice with a grain of salt! That said, I've been successfully using this workflow for the last six months of development. I've now shipped a full-featured demo on Steam, and I'm well on my way to finishing the game (hopefully in another six months or so). If you want to check out the demo and see what the fruits of this workflow look like, you can see it on steam
Emacs Configuration
The core of the configuration is hooking emacs up to Godot using eglot to connect to Godot's built-in language server (LSP), and then writing gdscript in emacs using gdscript-mode.
That combination gets you really excellent linting, code completion, detailed information in the minibuffer when you hover over a symbol, intelligent code replacement, and all the usual LSP features. You also get all of the same errors and warnings in emacs that Godot would show you in its own internal editor.
My config for those two components looks like this:
(use-package gdscript-mode
:defer 10
:hook
(gdscript-mode . eglot-ensure)
:custom
(gdscript-eglot-version 4.6)
:config
(require 'gdscript-mode)
(setq gdscript-godot-executable "/your/path/to/the/Godot/executable")
(setq gdscript-docs-local-path "/your/path/to/your/local/docs")
(setq gdscript-gdformat-save-and-format t)
(setq gdscript-use-tab-indents t)
)
(use-package eglot
:init
(setq eglot-events-buffer-config '(:size nil :format full))
(with-eval-after-load 'eglot
(add-to-list 'eglot-server-programs
'(gdscript-mode . ("localhost" 6005))))
)
Once this is up and running you can surface a lot of what gdscript-mode can do by pulling up the gdscript-hydra with "C-c r". You can also download an offline cache of the Godot docs from: https://docs.godotengine.org/en/stable/, then customize gdscript-docs-local-path to connect them to gdscript-mode. This gets you fast local lookup of Godot documentation in emacs.
That's the core of the config, but there are several other "nice to have" things:
If you're not already running an emacs-server, you should consider running one to make it faster and easier to open emacsclient frames from Godot. It can be as simple as:
(use-package server
:defer 10
:config
(server-start))
For completion I use the corfu and vertico completion suites with orderless and marginalia. Orderless completion in particular was a game-changer for me because you can start typing any substring or combination of substrings you know to be in the completion target in any order. This is especially useful when trying to get a specific node in a deeply nested scene tree in gdscript, which can be a pain with conventional "start at the beginning" style incremental completion.
For example, say I've got a complex UI scene with more than a 100 nodes in it. I want to address something deep in the tree like "$Other/MarginContainer/VBoxContainer/WeaponDirectionContainer/FireGroupButton". Orderless just lets me type the unique parts of the completion target, and they don't need to be connected or adjacent letters. In this case, typing "$FG TAB" gets me successful unique completion because the node above is the only one with both a capital F and a capital G anywhere in the name.
corfu/vertico/orderless are very well documented, and have sensible defaults, so it's really mostly just a matter of turning them on. Here's my (very minimal) config for these completion frameworks, but I'd encourage you to read their carefully documented sample configs to see if you want different options:
(use-package corfu
:hook ((prog-mode . corfu-mode)
:init
(setq corfu-auto t
corfu-quit-no-match 'separator))
(use-package vertico
:custom
(vertico-resize t)
:init
(vertico-mode))
(use-package orderless
:ensure t
:custom
(completion-styles '(orderless partial-completion basic))
(completion-category-overrides '((file (styles basic partial-completion)))))
(use-package marginalia
:init
(marginalia-mode))
Because indentation is load-bearing in gdscript, I personally found it very helpful to have a package to show contrasting highlights to show different levels of indentation. I use highlight-indent-guides, which is very configurable: you can set it demarcate indents using a color, a specific character (like a |), or a few other options. I have a dark emacs theme (gruvbox-dark) and like to use contrasting color fill for my indent highlights, but you may want different settings. I include my config as an example.
(use-package highlight-indent-guides
:init
(setq highlight-indent-guides-method 'fill)
(setq highlight-indent-guides-auto-odd-face-perc 20)
(setq highlight-indent-guides-auto-even-face-perc 35)
(setq highlight-indent-guides-auto-character-face-perc 15)
(add-hook 'prog-mode-hook 'highlight-indent-guides-mode))
Lastly, I also use a lot of other emacs features that aren't specific to my game development workflow. For example, I use org-mode to track tasks and todos, and magit for version control, but those are in a bit of a separate scope.
Godot-side Configuration
The main things to configure on the Godot side are a handful of editor settings to make Godot play nicely with emacs. Under Editor Settings-->Text Editor-->External you'll want to point it to the path to your local emacsclient executable (or plain emacs if you're not running a server), add any flags you need (I use -c {file} to make sure the Godot spawns a new frame whenever I open a script), and then check the box to use an external editor. Once you've done that, anytime you click to open or create a script in Godot it will open an emacs frame or buffer with the text instead!
The other thing to configure is under Editor Settings -->Network --> Language Server, where you should make sure that the language server is enabled on the port and host you set in your emacs configuration for eglot above. I also check the boxes to "show native symbols" and "use thread", which gave me slightly improved performance and richer information in emacs.
Day to Day Workflow in Emacs
So when I start development for the day I already have emacs open (because if my computer is on, emacs is open). Then I open Godot, and eglot connects automatically to Godot's LSP; Godot then opens the code frames I had open last time I was working, so I can start right back where I was.
When I'm in a buffer where gdscript-mode is active several keys work exactly as if I were in the main Godot editor. For example, if I want to test the game after making code changes, pressing f5 in emacs will run my main game scene and f6 will run the scene I'm currently editing. In both cases the command opens an emacs buffer with debug and console output so I can see the debug traces in emacs as I'm testing.
Additionally, while gdscript-mode doesn't provide linting for Godot scene files (.tscn files) they're also just plain text files too (see the spec here). You can edit them in emacs too if you're careful, and I frequently do.
As a result, I do about 80 percent of my core game work directly in emacs, and only really interact with the Godot interface when I'm doing level-design, UI layout, or animation type tasks where visually seeing things is important. Sometimes even those tasks are easier to do by directly editing the .tscn files in emacs (typically once the scene is already created in Godot and you're just tweaking values).
At the end of a coding session I disconnect eglot (eglot-shutdown-all) to ensure a graceful shutdown, open a magit buffer so I can stage and commit changes as necessary, and then run my build scripts. That's pretty much it!
I hope this answered the questions folks had in the other thread, and I'm happy to answer any new questions in the comments. I also wanted to reiterate how very grateful I am to all the folks who work hard to make emacs and its package ecosystem as excellent as it is!