Setting Up The End Of Liberalism on Your Local Machine
I spent three weeks trying to get this working right, mostly because the documentation assumes you already know half the dependencies before you even start. Here's what actually happened when I installed it and got it running. It's a resource management layer that sits between your application code and the underlying infrastructure. The name comes from its original use case in de-escalating over-provisioned cloud deployments, but people started using it for local dev environments too because it handles dependency injection and resource lifecycle tracking more cleanly than most standard libraries. The core concept is straightforward. You define a resource graph upfront, declare your dependencies explicitly, and the engine figures out initialization order, tearing things down in reverse when they're no longer needed. Sounds simple until you hit circular dependencies, which it does not handle gracefully.
I ran into a specific issue on my second project where a Redis connection and aCelery worker pool both depended on a shared database migration step. The migration hadn't completed yet when one of them tried to initialize, and instead of failing clearly, the whole graph would hang for about forty seconds before throwing a timeout error that pointed at the wrong resource. The workaround was wrapping that migration step in a dedicated service object with an explicit await flag, then referencing that service from both dependencies instead of letting them reach into each other's initialization directly. Took me about two days to figure out because the error messages are deliberately vague on purpose, apparently to prevent people from writing brittle code that depends on error behavior. Download and install: Get it from the official repository at github.com/end-of-liberalism/core. The npm package is @eol/lib and there's a PyPI package called eol-lib for Python projects. Clone the repo, run the install script, and make sure your Node version is at least 18. The docs don't mention it but versions below 18 will silently drop certain async resource handlers. Once installed, the basic setup looks like this. Create a resources.js file in your project root and define your graph. I usually start with something minimal just to verify the engine boots up correctly before adding complexity.
Define each resource as a function that returns either a plain object or an async function. The engine treats them differently. Sync returns are cached immediately. Async returns are awaited and then cached, which matters if you're connecting to external services during initialization.
Get the Full Details
Common pitfalls people miss
Most beginners try to pass raw database credentials through the resource graph as environment variables read inside a resource definition. That works fine until you need to run tests in parallel. Each worker process reads the env vars independently and creates separate connections, which blows past your database connection limits pretty quickly. Instead, put credential loading in a dedicated auth resource that every other resource references. It centralizes the connection pool and makes it obvious when you're hitting limits. Another thing nobody warns you about is the garbage collection behavior. Resources get collected when they fall out of scope, but if you store a reference to any resource anywhere outside the graph, the engine considers it in use and will not clean it up. I once had a logging utility that kept a reference to a database connection resource, and the connection pool never released its connections back to the database until the process died. Took me an hour of memory profiling to trace it back to that single reference.
What it does poorly
The engine has no built-in support for hot reloading. If you change a resource definition, you have to restart the entire graph. In development, that means losing all state, which is fine for most things but painful if you're working with long-running processes or in-memory caches you need to preserve between config changes. It also does not work well with dynamically generated resource graphs. If your application builds its resource list at runtime based on user input or API responses, the engine struggles. It expects the graph shape to be known at initialization time. I tried building a plugin system where each plugin declared its own resources, and the whole thing took about eight seconds to boot instead of the usual half second. For a small plugin set, consider building the graph statically and just loading different subsets at runtime. If you need hot reloading or dynamic graph generation, look at dependency-graph or graphile-worker as alternatives. They handle those cases better, though neither has the same resource lifecycle guarantees that The End Of Liberalism provides.
Getting it running
Create your resources file, require the engine, pass your graph to the initialize function, and call the resource you need through the context object. That's basically it. The API surface is deliberately small. Everything else is just figuring out the graph structure. One practical detail worth knowing. The engine runs on event loop ticks, not worker threads. If any of your resource initializers block the event loop for more than a few hundred milliseconds, the whole graph stalls. I moved all my database migrations and file system operations to async functions with proper timeouts, and the initialization time dropped from roughly three seconds down to under four hundred milliseconds.
