This "runtime" is what you are building with LangChain.. A harness like claude code/codex etc is general purpose and its env is a shell + tools. But with a custom runtime (basically a loop where we ask llm what to do next), we can give it specific tools which we define in code. This can help with things like authorization since, well its custom code you own.. so the runtime gets the tools scoped to the users permissions etc.

>Actually I will move my projects away from Railway

If you want a railway like experience, i have been building an opensource alternative to railway: https://github.com/axernel-labs/stackdome . Its mit-licensed and can run on a single vps to full-scale k8s clusters.

We started building Stackdome in 2024 as a hobby project. The idea was to package the tooling in the CNCF/cloud-native ecosystem into an opinionated platform, so that developers can get a well engineered platform without learning Kubernetes YAMLology or a dozen other projects from the CNCF landscape.

Railway and Render did this well for their hosted products. I wanted to bring that level of polish and DX to something you can self-host. Stackdome uses Kubernetes underneath, but it's completely transparent to users. (I have some ideas for an expert mode that exposes more of the bells and whistles.)

My day job involves working with cloud native technologies, and it made me appreciate how much is already solved by Kubernetes and the tooling around it. If you are already running Kubernetes, Stackdome is something you can adopt incrementally. (I have some ideas around adopting already-running workloads.)

Features:

- First class support for multi-service applications, shown on a canvas in the UI (inspired by Railway). You can edit, wire up, and create resources from the canvas.

- First class support for multiple clusters. Stackdome acts as the hub and places workloads across clusters (hub and spoke).

- Self hostable, from a small VPS to a large cluster.

- Managed Postgres with WAL archiving, HA, backups, and PITR (CNPG underneath).

- A release system for the whole stack. A release targets everything, and you can roll it back if something breaks.

- Source to image, with an in cluster registry (Zot).

- Disposable preview environments, which can also be multi-service.

- Declarative apps via a Stackfile, deployed with the CLI.

Website: https://stackdome.com

Docs: https://docs.stackdome.com

Repo: https://github.com/Stackdome/Stackdome

Set it up on a vps: `curl -fsSL https://get.stackdome.com/install.sh | sudo sh`

Or

Try it on our cloud, no credit card and no compute to bring: https://cloud.stackdome.com

Happy to hear your feedback and questions.

Comments URL: https://news.ycombinator.com/item?id=49285086

Points: 21

# Comments: 6

K8s tries to abstract away individual "servers" and gives you an API to interact with all the compute/storage in the cluster.

Comments URL: https://news.ycombinator.com/item?id=34231431

Points: 8

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=31395824

Points: 3

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=28681652

Points: 13

# Comments: 1

All this changed when I started learning Rust, man was I blown away by the language.. I never thought a statically typed language with manual memory management can feel so "scripting language" like.(Sure the borrow checker annoys you sometimes, nothing a `.clone()` can't fix when you are starting out). I truly enjoy writing Rust these days and never have I missed anything major from Ruby.

I'll be damned if I sit here and criticize Ken Thompson and Rob Pike, but I feel like in their quest to make Go "simple" they've perhaps held a little too hard on to their past.

tldr; Go feels a little too verbose and "dated" after learning rust.