Hyprland 0.55 announced the switch to Lua for its config files

by matesz • 3 days ago

141 141 3 days ago

cbarnes99• 3 days ago

This is kinda really old news at this point. 0.56 just came out.

I might be a good change but I left hyprland because,y configuration kept breaking. It's a good window manager so I'll change back once it gets stable. By now i3

m4xp• 3 days ago

I think the problem is with people downloading perfect configs from other people, I put the time to make my own, not overly complicated, basic window rules, nothing fancy. And it just werks, haven't changed it for 4 months (outside of rewriting it in lua, which took 30min and was quite fun).

My first hyprland experience was with ML4W (nothing against the guy) but as soon as you download it you get 10 config errors and you don't know where to begin. I took the same philosophy as arch, I install only what I understand, and this way my config grew over time, my games where spawning in 2nd monitor? I look up manual and fix it, etc..

kelvinjps102• 3 days ago

It was my own config, I just felt annoying because a fundamental part of my system didn't work. I end upf fixing it later but it was veryannoying

gchamonlive• 3 days ago

Hyprland config break is usually syntax changes or reallocated features. Never had an instance where hyprland broke beyond repair or was hard to fix, even before LLMs were a thing. But yeah, its a 0.x software so if you aren't keen on fixing small stuff it's better to wait indeed. My point is that hyprland is easy to fix.

colinsane• 2 days ago

i'm mildly annoyed by the project in general because i put in a sizable effort getting the whole sway stack to cross compile correctly in nixpkgs/NixOS, keeping that stable for a year so that people could build on it, and then suddenly hyprland forked every package in the stack with a fresh set of "works on my machine" nix expressions, and then much of the peripheral sway packages (e.g. status bars like nwg-panel, notification centers, etc) decided to become dual-stack and take a dependency on those fast-moving/beta packages. for a solid month any time i updated my machine there was a _new_ hypr-something dependency in my sway desktop that broke cross compilation. eventually i gave up and just set `hyprland = null; hyprutils = null;` in my personal config: mainline's been broken for a year now, sorry to anyone who was using that.

it gives "rewrite it in rust" vibes in the way they rush in to re-do everything without understanding why things were the way they were or if, in fact, anyone was using that obscure feature. maybe they'll sort it all out in time; maybe not. wish they could at least take less of a "we don't care if we break your shit" attitude in the meantime.

/rant

mintflow• 2 days ago

same boat, tried hyprland and it's cool but seems a bit buggy, and switch back to i3 and settle there.

Havoc2• 3 days ago

TIL I'm on 0.56 and hadn't realized there is a change.

Thinking I'll wait as long as I can and then just get an LLM to translate current config to lua once the internet has been seeded a bit with examples

feelamee• 2 days ago

there is a converter: https://eiontusk.github.io/hyprlang2lua/

Havoc2• 2 days ago

Nice. I'll give that a go. Pretty vanilla config so fair chance it'll work

pynappo• 2 days ago

there are already converters online (i wrote a incomplete one as a neovim plugin for fun https://github.com/pynappo/hyprlang-to-lua.nvim) and reportedly LLMs work fine at it too. At the time i wrote my converter there was already a couple hundred configs i could search through on github to see what people did

dietr1ch• 3 days ago

Old news? 0.56 is out now https://hypr.land/news/update56/

tombert5• 3 days ago

I have grown pretty negative opinions of “using a programming language as a config language” after semi-recently having to spend a lot of time screwing around with someone’s Gradle Groovy abomination. Not even to mention how quickly Nix can get annoying.

I have to ask…why do people want a Turing complete language to configure stuff? I use Sway personally, which is very configurable but for any even remotely complicated logic I shell out to a set of Rust programs.

mghackerlady• 3 days ago

I think it's only really useful for things you'd want to be able to control programmatically, like text editors or in this case window managers

adw• 3 days ago

The usual answer is "config macros", because if you don't give people something Turing complete they'll just m4 their way into Turing completeness and that isn't really an improvement. (Starlark in Bazel, etc.)

mickeyp2• 3 days ago

So you don't like using programming languages as config languages, so you:

1. Use a declarative-style format for config, which is fine, I guess; 2. ... and when that inevitably fails, you... use a programming language?

Some people -- not all, but some -- may prefer to skip the first step and go straight for the second option. Particularly if it's a complex thing indeed like a build system and not, y'know, configuring your blog.

AlotOfReading2• 3 days ago

The theoretical difference in power between a non-Turing complete declarative language and a turing complete one is irrelevant in practice. Datalog is a decidable, declarative subset of Turing-complete Prolog. It's also EXPTIME complete. I don't think we exclude any real use cases by prohibiting super-exponential algorithms.

The problem is shitty config languages. I wouldn't group xaml in the same category as dhall for example.

yjftsjthsd-h2• 2 days ago

and when that inevitably fails

This assumption is doing a lot of work. Surely the question was precisely why it would fail?

dlt713705• 2 days ago

2. ... and when that inevitably fails, you... use a programming language?

Maybe it fails because you are trying to solve a problem with a configuration when it should be solved by a function implemented in the program you are trying to use.

ianburrell• 2 days ago

Those aren't the only two options. There are non-Turing complete config languages like Cue, Dhall, and Jsonnet that are designed to complete and be consistent. They work well when did to generate static config from some dynamic input generated by regular program.

sureglymop• 2 days ago

It's interesting because this is exactly what I used to do for my hyprland config (which the op is about). I had some keybinds that would shell out and use a script with the hyprctl cli.

Now it's all a single simple lua function and 3x as fast... I think this change is great.

preg_match• 2 days ago

Typically you force a split. Configuration is one thing, plugins are another. Maybe you can reference plugins from your config, but not express logic there. Boom, now you have both.

It also means your plugin system doesn't have to choose an "easy" or "simple" language. You could use wasm if you wanted to and allow just about everything under the sun. Although, Lua is used for Roblox games so, maybe it's complex enough.

0x20cowboy• 3 days ago

Because it almost always devolves into that anyway. Every yaml system I have ever worked in winds up with some layer on top to “generate the yaml” or some other such madness.

ufo• 3 days ago

In fact, that's how Lua itself came to be. They started with a simple configuration language and added more and more features until at some point they decided to rip the bandaid and turn it into a proper programming language.

pie_flavor3• 3 days ago

It is good to keep a configuration simple enough that it doesn't need to be a programming language.

The absolute moment you find yourself thinking of putting conditional logic, or string substitution, or anything like that, in your pure config format, switch to a real programming language, before you end up managing several times the complexity of one with only some of the benefits. No need to end up contemplating some sort of for-loop macro with another key referencing the loop variable, when you can just have a for loop.

I find TOML, in addition to being very readable, to be great at automatically restricting config complexity by making nested lists of tables miserable. If your config sucks at being TOML, it should be JS or Python. (Not a fan of Lua.)

crowdyriver• 3 days ago

python is terrible for embedding, starlark is the way to go. Very easy to embed.

skydhash2• 2 days ago

The absolute moment you find yourself thinking of putting conditional logic, or string substitution, or anything like that, in your pure config format, switch to a real programming language, before you end up managing several times the complexity of one with only some of the benefits

That’s where you add a plugin system or an ipc mechanism, not a whole programming language.

matesz• 3 days ago

I have to ask…why do people want a Turing complete language to configure stuff?

I don't understand this either. IMO, the current SOTA tool for configuration is CUE, because it is the only one that lets you write schemas for arbitrary refinements. I haven't used it myself, but my understanding is that everybody should be writing configurations in something like this instead of YAML, TOML, HCL, or a custom DSL with no tooling. And yes, definitely not in a Turing complete programing language.

ciupicri• 3 days ago

the current SOTA tool for configuration is CUE

the current state of the art tool for configuration is CUE (https://cuelang.org/). FTFY. Gotta love these acronyms.

LelouBil• 2 days ago

Cue is amazing, I'm using it to configure my kubernetes homelab.

I CANNOT imagine what horrors it would be to do it all with helm or templating.

skydhash2• 3 days ago

I have grown pretty negative opinions of “using a programming language as a config language”

Same here. I like the openbsd approach of small DSL (pf, doas) or just simple ini-like key-value config (sysctl, rc.conf). If you want more, just patch the software and be done with it.

A programming language is OK if the intent is to build a platform (Emacs, Vim) but for something that is purely an application software, it's very much not necessary.

weinzierl2• 3 days ago

I think INI-style config is one of the few good things that came out of the Microsoft/Windows ecosystem. Shame that it is so underspecified. We have TOML, of course, but I think for stupid config even that is too much.

The intersection of INI and TOML would be perfect.

andrewshadura• 3 days ago

Isn't that called TOML?

hiccuphippo• 3 days ago

What would you remove from TOML to make it perfect?

0x457• 2 days ago

TOML was created purely because INI has no format spec at all. So what you want is just TOML.

If you don't like certain things, just don't use them in your configs (i.e. tables)

MantisShrimp90• 3 days ago

Half of me agrees with you. As someone who used to tinker with neovim all day I've had to learn just because you can program the problem doesn't mean you should and stick to a relatively minimal config.

Still, its a valid design choice with different design decisions compared to sway. But that's the point you get to choose.

Hyprland is much more "build your workspace with legos" so having a full lang like lua makes sense to properly integrate the various pieces.

zeratax3• 2 days ago

imo the downsides to this are so minimal to a user? you can configure neovim without defining any functions or w/e and it's not like awkward or anything

LatticeAnimal• 3 days ago

I like the ability to introspect the system. I have a lua LSP, when I edit lua config files, I know all of the fields of the config I am editing, and I know how they behave (without randomly trying things)

stephc_int13• 3 days ago

I fully agree with that.

Past experience has shown what while Turing complete config is powerful, it is also a double edged sword and I would be wary of using it.

simlevesque• 3 days ago

The thing is that if your config language isn't Turing complete, the community will create N softwares to generate dynamic configs.

hombre_fatal• 3 days ago

If you look at hyprland config, you can see why they went with it.

Much like vim/neovim config, people want to do things like register a callback that fires to determine the window title and things that are much more advanced than that, like layout management.

When I was using sway, I was using its IPC or worse (https://github.com/johnae/persway) to do advanced things, and Lua scripting in the first class config would have been a much better UX.

honeycrispy• 3 days ago

I have to agree. There are things that I want to do with my sway scratchpad that are just not possible because the config vocab is so limited. I might port my config to hyprland and give it a shot.

yjftsjthsd-h2• 2 days ago

That feels like a plugin or external program, not configuration

tombert5• 2 days ago

I did run Awesome for awhile and I liked it, but I never used the Lua config for the most trivial things so it never got in the way of anything.

I never found that Sway too annoying to just use the shell commands to grab/modify the current state of Sway (https://github.com/tombert/rs-swanbar) and just use a "real" programming language to actually do any kind of programming logic. To each their own!

phire• 2 days ago

It looks like the previous hyprland config language was already getting close to being Turing complete;

Already has variable substitution and math, it seems to falls short of Turing completeness only because I don't see any form of recursion. But recursion is something it could accidentally gain if someone decided to add templating to the language.

Besides, looks the config files can call out to external executables, which absolutely are Turing complete. And moving to lua might actually simplify configs by allowing more things to be done inside the config system, rather than calling out.

marginalia_nu• 3 days ago

Yeah I think there are two basic routes that work. Either you have a declarative configuration, or you go the route of Emacs and make the entire thing programmable.

Turing complete configuration languages suck and makes everything slow, janky and difficult to reason about.

vvillena• 3 days ago

It depends a lot on the config language. Gradle has the uncanny ability to be a "worst of both worlds" option, where there are not many upsides to its using a full language for its configuration. Build configuration is also a space where people and even some tooling seem to forget about good engineering practices, giving birth to fragile builds that people are afraid to modify and improve.

mhitza• 3 days ago

I want a programming language as soon as the program benefits from conditional clauses or subsystems. So if the will and know-how is there, would be great to have it from the start.

I was pretty happy the day I could move some Jenkins jobs to a Groovy script. I've worked with HCL significantly, but once I learned the idiosyncrasies of Pulumi, scripting infrastructure via a programming language was a better experience (good IDE autocomplete simplified things), though it requires more discipline.

Even without working with the Nix scripting language I'll dismiss it. When I looked at it was some kind of bastardisation of Bash with Haskell ideas. A hobby project idea at best, yet forced upon all Nix users. Guile Scheme is a nice small language, and Guix uses that, and I think that is a better approach.

isityettime2• 2 days ago

Nix isn't a scripting language in the sense you seem to have in mind. The snippets you saw that looked like Bash most likely were literally Bash, embedded as multiline strings in Nix.

Nix doesn't have much in common with Haskell.

Nix is a really small language, and you can learn pretty much all of it in a few minutes: https://nixcloud.io/tour/?id=introduction/nix

NoboruWataya• 3 days ago

I don't dislike it but I do think it's interesting that a number of minimalist WMs seem to have converged on the idea of code as config. I have used AwesomeWM for years and love its Lua configuration for providing infinite flexibility. When I was recently looking for something like AwesomeWM but in Wayland I toyed with the idea of moving to something with a simpler config format (and Hyprland was one of the options I considered). I can see the benefit of the simplicity but I guess for the kinds of users that use these WMs, maximum configurability probably trumps everything else. (Currently I am using SomeWM which is just an attempt to get something as close as possible to AwesomeWM in Wayland.)

Personally I have grown a bit frustrated with Lua as a language, but at the same time can see why it would be a good choice for this use case.

jolt42• 3 days ago

I think the progession is like 1) Oh, I can break stuff by changing a config value - it doesn't protect me. 2) Oh, I didn't think X would need to be configurable. 3) With code I can colocate the values with the code that uses them - easier to understand, and I can "configure" anything I want. 4) Why are we using configs?

vbernat• 3 days ago

I have switched from FVWM to awesome because of Lua. Many years later, I have switched to i3 because it's not using a programming language for configuration. It's fine to have a configuration language if you have time to maintain, but your configuration can become quite complex and difficult to evolve. And it is also far more subject to breakage when upgrading.

I think I've found balance by using a Python daemon as a "companion" for my i3 configuration. It listens and react to event. It enhances the configuration, so when it's broken, it's not a big deal. And the interface exposed by i3 is smaller, so less risk of breakage. https://vincent.bernat.ch/en/blog/2021-i3-window-manager#i3-...

mort96• 2 days ago

All these window managers have a Turing complete configuration language, because you need to do things in response to events (keyboard hotkeys etc). It's just that for most of them, the "Turing completeness" happens through passing around strings with shell snippets. Might as well be a Lua callback function.

crest• 2 days ago

A window manager / compositor is one of the few things where I can see this making a lot of sense. The alternative of using an IPC socket for everything would be more complex and require users to reinvent the wheel all the time. Also it makes low latency synchronous reactions to events really hard to implement well.

kibwen3• 2 days ago

Seconded. Your configuration should be a simple declarative language with no Turing-complete escape hatches. Turing-complete configuration languages are the devil. That goes for build systems too: if you absolutely need Turing-completeness in your build system (my condolences for the hellscape you inhabit), use a separate task runner that does its arbitrary nonsense before dispatching to an underlying build system with declarative configuration.

nimih• 2 days ago

Speaking personally, there are essentially two distinct reasons I like having programmable config languages:

- For personal application config (window manager, shell, text editor, etc), I find I often want to have site-specific configuration, but I also want identical configuration files at every workstation. My laptop probably needs slightly different keybindings than my desktop, my $PATH and text editor needs to be configured a bit differently for work than for personal use, etc. When the configuration is done with a real programming language, this is always straightforward, when it's done via a json/yml/toml file, it's usually a huge pain in the ass.

- You want templating for your configuration, to improve readability, reduce typos and configuration drift, &c, but if you give programmers an inch with any sort of templating system, they will eventually take a mile and figure out how to smuggle Turing-completeness (or, at least, for-loops and variable binding and probably closures) into their configs. If you have a real programming language, this is fine, because the programming language was designed to make loops and conditionals and function calls readable, and probably has decent tooling to boot, but if they're doing it with, say, Mustache-templated YAML, you will have an unreadable mess that is extremely unpleasant to work with.

corysama• 2 days ago

Lua was specifically designed to be a configuration language https://www.lua.org/history.html

Lots of people start out with a non-programmable config format. But, as their situation becomes more complicated, they end up shoehorning in programmable-ish features until they realize they are running straight into https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule and decide to do it properly.

tombert5• 2 days ago

I mean, fair enough I guess. I've accidentally more-or-less reinvented interpreters on two separate occasions (both times using JSON as a quasi-AST), so I understand it.

I guess I just feel like if you feel like you need programming constructs in your configuration, its approaching it from the wrong angle, and it should instead be handled via plugins.

I feel like configuration itself should be a "dumb" format like JSON, and when you want to do anything that can't be accomplished by plain JSON, you should allow for easy development of plugins.

newobj• 2 days ago

if you get into a config system that's complicated enough, and has modularization or inheritance, you'll know that the semantics of "remove this" "add that", override this, default to this, this stuff is hard to express in most config languages, or worse, you start enforcing application level semantics. when you have turing complete language you just ... do those things. we reduced the configuration data of a tool suite once by 90%+ by moving from json to python. there was a tremendous amount of duplication and overlap, with tons of TINY exceptions and variations. it was so hard to see those differences, brittle to maintain, things would get stale, ... moving to python you basically had the "base" thing expressed in one file, and a bunch of tiny delta files encoding the exact deviations. All those deviations were of the forms I described above. Adding a thing to a list. Removing a thign from a list. Overriding a whole list. Do a thing if not already done. And so on. It's also then easy to build all kinds of diagnostics, validators, etc, right into the same framework, without having to munge the data into some other form first.

Barrin92• 2 days ago

I have to ask…why do people want a Turing complete language to configure stuff?

because it lets me configure programmatically. Practical recent example, I use Wezterm which uses Lua as a config language but I tried out Ghostty and because I use all operating systems regularly I have a lot of 'if this then that' in my Wezterm config, different default shell, different key bindings etc. With Ghostty my only option is to maintain different config files per machine.

And what's worth pointing out is that Ghostty does have an operator for this('?' I think) which means there's already a bit of programming in it, except what always happens is that software with declarative config files invent their own scripting an templating languages as more and more people demand it, so just give me lua or lisp from the beginning and we're good.

nickjj3• 2 days ago

With Ghostty my only option is to maintain different config files per machine.

This turns out to be a benefit IMO.

Ghostty supports include files. You can have all of your shared config in 1 main config and then have small files that are included which are machine specific. My dotfiles uses it and it supports Linux and macOS. Example: https://github.com/nickjj/dotfriedrice/blob/master/.config/g...

You can have something like this in your Ghostty config: config-file = ?config.local

And then on each machine that's different, you can have your machine specific config in ~/.config/ghostty/config.local or whatever you decide to name the file.

It works out nicely because config options are merged, so the local file can overwrite what's in the main config. This lets you deviate from the original git committed config without needing to modify it. Super handy for public dotfiles.

uncletaco• 2 days ago

I never really felt like scheme got annoying when configuring guix. I’m half certain most of my configurations for Guix services were just yaml configs with s-expressions

somat• 2 days ago

It smells like a variant of inner platform effect. Where in order to save you from programming the the config is super flexible, What is missed is that you are still programming only now you have to do it in some weird context.

At least in this case it is an actual programming language instead of XML or YAML like so many of them.

An alternative slightly more charitable interpretation is this is the engine/gamelogic pattern. But the difference between the two is more subtle than it naively appears depending largely on proper layer segmentation.

crote• 2 days ago

Because there's a never-ending stream of plausible use cases where it just missing one little option. Just look at the web: people have done all sorts of horrible stuff in Javascript to make up for missing HTML / CSS properties.

At a certain point it becomes incredibly tempting to just give up on playing whack-a-mole and let the most demanding users do it themselves using a proper programming language.

chuckadams2• 2 days ago

I would agree that turing-complete config is more trouble than it's worth when the config is something you might need to reason over, such as a build definition in Gradle. But for something like a window manager config where everyone's config is a snowflake, it's kind of ideal. Horses for courses and all that.

HiPhish2• 2 days ago

I have to ask…why do people want a Turing complete language to configure stuff?

What's the alternative? Petition the maintainer to add every little feature any random user might want? Or just do it yourself in a few lines of code?

Case in point, when I was still using BSPWM I did no like how if there was only one window on the desktop it would still get an outline. So I wrote 14 lines of Awk (BSPWM lets you use any language) to get what I want. This was only possible because BSPWM gives me all the primitive building blocks and lets me go wild with them. Sure, if all you want to do is set a few colors and numbers that's overkill, but any power user will sooner or later find himself thinking "oh, if only I could do X when Y unless Z".

tombert5• 2 days ago

I think having good plugin support is a better way to do it. Keep the most obvious configuration options behind a "dumb" config language like JSON or something, but create a framework to add functionality via a plugin API.

eviks7• 2 days ago

Because you are less limited by all the mistakes the designers encoded in the static files

zeratax3• 2 days ago

i find nix a weird mention here. there is a popular segment of people who wish nix would have used a generic programming language instead of a dsl, but i cant imagine nix working with something like toml ever. the complexity to build every program ever in every programming language is just way too high for that.

JacobAsmuth• 3 days ago

Huh? This is from May. You guys should read the more recent notes. https://hypr.land/news/update56/

stonogo• 2 days ago

Nothing in those notes is interesting, but switching to Lua is. It doesn't matter that it happened a few weeks ago.

ianm218• 3 days ago

Related to Lua - I've been maintaining this project that has Lua 5.1-5.5 in one Rust project [1]. The main reason to use it over mlua or the normal C Lua is for something that plays nicely with WASM/ general cross compilation or wants to support several different versions of Lua.

Seems like hyprland is on C++ so maybe not a direct use case but thought Lua people in general might be interested.

[1] https://github.com/ianm199/omnilua

v3ss0n• 3 days ago

That's why I love qtile, written in python, modify everything in python, can import any module of it and can install anything, extend existing layout without forking to support very interesting and customized WM layouts, all entirely in python, call any python code in WM.

qiine• 3 days ago

lua is love

leephillips2• 2 days ago

I think dwm has the best approach to configuration: change the program and recompile.

This works for dwm because it compiles in two seconds and has minimal dependencies. I don’t know about hyprland.

https://dwm.suckless.org/customisation/

drdexebtjl2• 2 days ago

Requiring a C compiler, source code and header files to change your keybindings is just a different kind of bloat, and nothing can change my mind.

leephillips2• 2 days ago

Then I won’t try! And I understand your opinion. But like everyone else I have many programs using many different configuration syntaxes, some using more than one file, some files in nonstandard locations, and some combining configuration from one or more files in my user directory with others somewhere in /etc or who knows where. I find the dwm approach refreshing.

Pontification added later: And it has a beneficial side-effect. I’m not much of a C programmer these days (if I ever was), but I found I was able to understand the dwm code well enough to make some small changes in behavior. So the dwm approach encouraged me to go beyond changing definitions in the headers. (This is aside from 3rd party patches. I was even able to contribute one of those.) This is really in the spirit of free software.

IshKebab2• 2 days ago

I wish there was something better than Lua and just as "obvious" a choice. Static types, real arrays, zero-based indexing, etc.

Closest thing I've seen so far is Roto: https://roto.docs.nlnetlabs.nl/en/stable/index.html

Basically everything about this looks great - Rust-style syntax, static type checking, sane type system, easily embedded. The only slightly odd things are that it has built in types for IP addresses, AS numbers, and `filtermap`. But I guess you can just ignore those if you don't need them.

eqvinox• 2 days ago

The language is primarily used by Rotonda, the composable, programmable BGP routing engine.

Not odd to have those data types at all…

LoganDark• 2 days ago

Better to let specific domains define their own data types than favor one in the language.

IshKebab2• 2 days ago

Yeah it makes sense for their use case. I meant it was an odd thing to have if you were using it as a general purpose language like Lua.

rdtsc6• 2 days ago

It's just part of what I call the config pendulum.

Simple config -> (Need to do more complicated things) -> Add override levels -> (Need even more flexibility) -> Add a Turing complete language -> (Things get ridiculous, lots of spaghetti code outside of version control. Time for a reset) -> goto "Simple config"

It's fine. I am not saying it's wrong or right. I've gone through the cycle a few times in some projects. On the other hand, think of it as your project is lucky to be used long enough to have these problems. To feel better about it think of it as a spiral. The next "Simple config" is a slightly better version of the first.

PunchyHamster2• 2 days ago

I haven't really seen program go back from "a programming language" to a simple config format.

serf• 2 days ago

there's a rare form of that where it goes from( simple -> programming language -> language with DSL support -> simple dsl ) ; emacs has followed this model a bit.

rdtsc6• 2 days ago

Python setup.py -> pyproject.toml? Make -> ninja. eBPF kernel modules from C to a custom language. Helm Go templates -> Kustomize.

I am sure there are other projects picking up json from a previous xml + xpath + other ...xml junk.

zetanor• 2 days ago

WirePlumber switched its config from Lua to a JSON variant not so long ago.

ossopite• 2 days ago

I've seen this expressed similarly as the 'configuration complexity clock': https://mikehadlow.blogspot.com/2012/05/configuration-comple...

I like your spiral metaphor though, since you learn some things along the way.

arikrahman2• 2 days ago

That's clever insight. If it was lisp from the beginning, maybe would be more straightforward. It's as simple as code can get, according to Uncle Bob, while still being expressive. It's no wonder Emacs still reigns supreme. Well, I am happy with Niri's kdl approach for the time being.

seanw444• 2 days ago

It can be Lisp if you want it to be. Just use Fennel. That's what my Hyprland config is written in.

rdtsc6• 2 days ago

Lisp/scheme is probably a rare case where it sort of works either way and easy to switch without any extra work, since data and settings already look like code. At some point I had used s-expression as config (before json was widespread, I am that old) but that never had a full on evaluator to actually execute code.

SuperNinKenDo• 2 days ago

Emacs seems to do a pretty good job handling this with the "Customize" interface. Presents a bunch of variables the user is intended to customise in something resembling a familiar interface, then it inserts the values into the Elisp init file. Someone could use and customise Emacs for years and never really touch Elisp directly. But then, oh, those text fields actually take lists, which in Emacs Lisp is the same as taking code. Maybe you use that for a while until you get comfortable and wanna try modifying something not surfaced in "customize", where you can discover init.el, etc. Etc. It's not perfect, but to me it's really close, it's the model of progression I wish all UIs for customisation used, personally.

shiomiru• 2 days ago

I like to have a simple config AND a real scripting language. That way, the UX for changing "simple" things remains straightforward (you can even add a config editor panel), while for less simple things you can use a real programming language (reducing pressure from the "simple" config to turn into a DSL).

iamrecursion• 2 days ago

I've tended to find a lot of value in systems that have both, especially when there is automatic translation from the simple config to the Turing complete language. Lean 4's lakefiles are a good example of this, with a TOML format that is a subset of the Lean DSL format.

rdtsc6• 2 days ago

That's a neat pattern. It's interesting to think how many times users can auto-generate the DSL and how many times they end up having to write the DSL directly.

eviks7• 2 days ago

That seems like a huge waste of time for anything slightly complicated to convert code to simple configs and lose a lot of functionality in the process. Do you have an indication of how prevalent the cycle is in reality?

rdtsc6• 2 days ago

That seems like a huge waste of time for anything slightly complicated to convert code to simple configs and lose a lot of functionality in the process.

That's usually done in anger by people who have to read and update someone else's pages long "config" file, possibly outside version control, with lots of loops and external resource fetches and so on tearing their hair out "why isn't this a just a toml/json/yaml file".

SAI_Peregrinus• 2 days ago

This is why I like to keep the concepts of "config" and "plugin" separate.

rdtsc6• 2 days ago

Yeah I like that too. You can have both of course.

PessimalDecimal• 2 days ago

Lisp is the perfect family of languages for a config. Homoiconic for seamless config generation. S-expressions for shared human and machine readability.

ivanjermakov• 2 days ago

Lua too. Neovim and Factorio come to mind first.

nickjj3• 2 days ago

It's neat that Hyprland lets you define layouts in its config but I like niri's approach.

It uses KDL (an established document / config language) and slightly extends it to add useful things like being able to include files.

For example, here's mine: https://github.com/nickjj/dotfriedrice/blob/master/.config/n...

What you end up with is a config file that's natural to read with no prior knowledge about anything and if you want to look something specific up, you know it's officially documented and not some home grown pattern someone created. There's a certain amount of comfort and stability you get with a "what you see is what you get" approach.

I never felt like I needed variables, conditions, functions or loops with niri's config.

WhyNotHugo3• 2 days ago

I wouldn't call KDL "established"; it's honestly pretty niche. It looks _similar_ to pre-existing configuration formats, but KDL is very picky about syntax. I.e.: single word string MUST be quoted.

In this same space, https://codeberg.org/emersion/scfg/ is pretty widely used. The curious thing about scfg is that it's not really a "new" format: the syntax described has been in use by different tools for decades. They just didn't call it scfg, and it's mostly the name itself that's new.

eviks7• 2 days ago

picky about syntax. I.e.: single word string MUST be quoted.

Seems like the opposite:

Example from kdl website without quotes

package { name my-pkg

Example from scfg with quotes

train "Shinkansen" {

nickjj3• 2 days ago

It is picky, but picky is good. It's explicit which creates uniformity.

For example with niri, if you forget quotes on a string value, you get this error.

    $ niri validate
    Error:   × error loading config
      ├─▶ error parsing
      ╰─▶ error parsing KDL

    Error:   × identifiers cannot be used as arguments
        ╭─[config.kdl:42:1]
     42 │         // Disable acceleration.
     43 │         accel-profile flat
        ·                       ──┬─
        ·                         ╰── unexpected identifier
     44 │     }
        ╰────
      help: consider enclosing in double quotes ".."

trollied• 2 days ago

Auto play video when you scroll? Behave

JCattheATM• 2 days ago

I wonder how this would make Hyprland compare to Pinnacle or Awesome? So far I haven't found anything better than Awesome for crafting a bespoke desktop experience.

retrochameleon• 2 days ago

Uggghhh, I hate Lua. I hate the syntax, everything being tables, and.... dun dun dun 1-indexed arrays.

I wish we wouldn't keep going back to it. I understand the appeal for some use cases, but pleeeeeeease can we just move on to a new language that fulfills the same use cases but with more typical conventions?

eviks7• 2 days ago

What's your best alternative for this use case?

sph• 2 days ago

I want to like Hyprland, but it truly is the embodiment of Jamie Zawinski’s “cascade of attention deficit teenagers”

This is what happens when software is created by too-smart teenagers, that change their mind as fast as they improve at programming, and expect that everyone is spending 12 hours a day configuring their desktop environment while hanging out in ‘ricing’ discords (“what do you mean you have a day job?”)

Worse, if you dare criticize it, the fanboys come out of the woodwork saying you should really just use an LLM to convert to Lua and that you are dumb trying to do it manually. The hubris is untenable.

After 3 or 4 breaking changes over the years, I decided I’d rather use some other desktop environment honestly, until the core team literally grows up. Niri is great, and its author is much more… mature.

hackeraccount• 2 days ago

You're like a smarter more articulate version of me.

I used to use Sway - switched to hyperland very briefly and it was so busy and a pain to work with.

Niri on the other hand is as complicated as I want it to be.

eviks7• 2 days ago

Wish there were a more widespread config system where you could use a wider range of languages and not be limited to a single bad ancient one.

Hyprland 0.55 announced the switch to Lua for its config files

Related Stories