HNHacker News
TopNewBestAskShowJobs

ajayvk

278 karma · joined March 27, 2011

Building https://github.com/openrundev/openrun, a platform for deploying internal tools.
submissionscomments
ajayvk··on Scaling request logging with ClickHouse, Kafka, and Vector
Yes, had similar questions. Wouldn't tuning the settings for the buffer table have helped avoid the TOO_MANY_LINKS error?
ajayvk··on AWS Service Availability Updates
If you are fine with running lots of apps on one beefy machine, the project I am building https://github.com/openrundev/openrun provides a similar abstraction as App Runner and Cloud Run (automatically deploy web apps from source). It supports scaling down to zero, but does not yet scale an app beyond one container.
ajayvk··on Ask HN: What are you working on? (October 2025)
I have been building OpenRun, a declarative web app deployment platform https://github.com/openrundev/openrun. It is an open source alternative to Google Cloud Run and AWS App Runner, running on your own hardware.

OpenRun allows defining your web app configuration in a declarative config using Starlark (which is like a subset of Python). Setting up a full GitOps workflow is just one command:

  openrun sync schedule --approve --promote github.com/openrundev/openrun/examples/utils.star
This will set up a scheduled sync, which will look for new apps in the config and create them. It will also apply any config updates on existing apps and reload apps with the latest source code. After this, no further CLI operations are required, all updates are done declaratively. For containerized apps, OpenRun will directly talk to Docker/Podman to manage the container build and startup. There are lots of tools which simplify web app deployment. Most of them use a UI driven approach or an imperative CLI approach. That makes it difficult to recreate an environment. Managing these tools when multiple people need to coordinate changes is also difficult.

Any repo which has a Dockerfile can be deployed directly. For frameworks like Streamlit/Gradio/FastHTML/Shiny/Reflex/Flask/FastAPI, OpenRun supports zero-config deployments, there is no need to even have a Dockerfile. Domain based deployment is supported for all apps. Path based deployment is also supported for most frameworks, which makes DNS routing and certificate management easier.

OpenRun currently runs on a single machine with an embedded SQLite database or on multiple machines with an external Postgres database. I plan to support OpenRun as a service on top of Kubernetes, to support auto-scaling. OpenRun implements its own web server, instead of using Traefik/Nginx. That makes it possible to implement features like scaling down to zero and RBAC. The goal with OpenRun is to support declarative deployment for web apps while removing the complexity of maintaining multiple YAML config files. See https://github.com/openrundev/openrun/blob/main/examples/uti... for an example config, each app is just one or two lines of config.

OpenRun makes it easy to set up OAuth/OIDC/SAML based auth, with RBAC. See https://openrun.dev/docs/use-cases/ for a couple of use cases examples: sharing apps with family and sharing across a team. Outside of managed services, I have found it difficult to implement this type of RBAC with any other open source solution.

ajayvk··on Show HN: OpenRun - Deploy web apps declaratively
Any repo which has a Dockerfile can be deployed directly. For frameworks like Streamlit/Gradio/FastHTML/Shiny/Reflex/Flask/FastAPI, OpenRun supports zero-config deployments, there is no need to even have a Dockerfile. Domain based deployment is supported for all apps. Path based deployment is also supported for most frameworks, which makes DNS routing and certificate management easier.
ajayvk··on Traefik's 10-year anniversary
I have been building an app deployment service https://github.com/openrundev/openrun.

For the use case of network routing for services running in containers, OpenRun provides a simpler abstraction. It does the container management and the network proxying.

ajayvk··on Cloud Run GPUs, now GA, makes running AI workloads easier for everyone
Clace is built to run on a single machine without needing Kubernetes. The plan is to add support for Kubernetes hosting later, but running on one or a few machines should not required Kubernetes.

Clace is built for the use case of deploying internal tools, so it comes out of the box with CI/CD, auditing, OAuth etc. With Kubernetes, you need to glue together ArgoCD, an IDP etc to get the same.

ajayvk··on A masochist's guide to web development
A recent improvement in import map support in the browser https://shopify.engineering/resilient-import-maps
ajayvk··on Cloud Run GPUs, now GA, makes running AI workloads easier for everyone
https://github.com/claceio/clace is project I am building which gives a Cloud Run type deployment experience on your own VMs. For each app, it supports scale down to zero containers (scaling up beyond one is being built).

The authorization and auditing features are designed for internal tools, any app can be deployed otherwise.

ajayvk··on Clace AppServer – GitOps in a single command
I have been building https://github.com/claceio/clace, an application server for deploying containerized apps. Docs are at https://clace.io/.

There are many deployment tools focussed on simplifying containerized apps deployment. Most of them are built as wrappers on top of Nginx/Traefik/Caddy etc. Clace is a single binary which implements a web server and an app server. This allows Clace to implement features like OAuth and atomic updates which are not possible for other solutions. Clace focuses on making it easy for teams to deploy Streamlit/Gradio/FastHTML type apps with no config required.

Clace has a imperative CLI and it has a declarative GitOps interface. For example https://github.com/claceio/clace/blob/main/examples/utils.st... is a config which defines seven apps. Using Starlark (pythonic syntax) allows easy config without the YAML insanity.

Running a command like

   clace sync schedule --approve --promote github.com/claceio/clace/examples/utils.star
is all it takes to setup full GitOps, starting a background sync which creates new apps and updates existing apps with three way merge.
ajayvk··on Show HN: First AppServer built for deploying containerized apps
I have been building https://github.com/claceio/clace, an appserver for deploying containerized apps. Docs are at https://clace.io/.

There are many deployment tools focussed on simplifying containerized apps deployment. Most of them are built as wrappers on top of Nginx/Traefik/Caddy etc. Clace is a single binary which implements a web server and an app server. This allows Clace to implement features like OAuth and atomic updates which are not possible for other solutions. Clace focuses on making it easy for teams to deploy Streamlit/Gradio/FastHTML type apps with no config required.

Clace has a imperative CLI and it has a declarative GitOps interface. For example https://github.com/claceio/clace/blob/main/examples/utils.st... is a config which defines seven apps. Using Starlark (python like) for config allows easy config without the YAML insanity.

Running a command like

   clace sync schedule --approve --promote github.com/claceio/clace/examples/utils.star
is all it takes to setup full GitOps, starting a background sync which creates new apps and updates existing apps with three way merge.
ajayvk··on Tilt: dev environment as code
Starlark does allow for much more concise and powerful config specification. I am building https://github.com/claceio/clace, which is an application server for teams to deploy internal tools.

Clace uses Starlark for defining apps, instead of something like YAML. https://github.com/claceio/clace/blob/main/examples/utils.st... is a config file which defines around seven apps (apps are downloaded and deployed directly from git).

Clace uses Starlark for defining app level routing rules also. This avoids the need to use a nginx like DSL for routing.

ajayvk··on The appeal of serving your web pages with a single process
Having a single process web/app server simplifies things operationally. I am building https://github.com/claceio/clace, which is an application server for teams to deploy internal tools. It runs as a single process, which implements the webserver (TLS certs management, request routing, OAuth etc) as well as an app server for deploying apps developed in any language (managing container lifecycle, app upgrades through GitOps etc).
ajayvk··on Deploy from local to production (self-hosted)
Thanks. Clace is built for teams to be be able to deploy internal tools (Streamlit/Gradio etc). That use case requires some extra features (OAuth/Auditing/Declarative config etc). Kubernetes with ArgoCD plus IDP seems to have become the default solution, which is overkill for such use cases.

The Hypermedia based app support was added to be able to build a management dashboard for Clace itself, without going down the SPA route. It made sense to expose that for end uses to be able to build their own apps.

ajayvk··on Deploy from local to production (self-hosted)
Another option you could consider is a tool I have been building for deploying webapps across a team. https://github.com/claceio/clace has the usual deployment related functionality like gitops, TLS certs.

It has some unique features like supporting OAuth authentication for the apps, staging env for each app (code and config changes are staged before deployment), supporting declarative update, supporting hypermedia based apps natively etc.

ajayvk··on Gixy: Nginx Configuration Static Analyzer
I have been building a platform [1] which makes it easy to deploy internal tools. Instead of taking the config file approach, it allows you to install each app at a unique location (domain name + url path). Within its location, the app owns all the URLs and can managing request routing without requiring a global config update.

The advantage is that new app installations cannot interfere with an existing app. I wrote more about this approach at https://clace.io/blog/webserver/

[1] https://github.com/claceio/clace

ajayvk··on App-Level Isolation in Web Server Config
Yes, it would be great if this approach becomes more common for web servers.

Since Clace is built for internal tools, even new app installation can be done by regular users. If the namespace is available, a new app can use that without conflicting with other apps.

ajayvk··on App-Level Isolation in Web Server Config
Web server config which is a blob of text is a pet peeve of mine. This makes every config update risky and simultaneous updates by multiple users is difficult to coordinate.

This presents an alternate approach for handling web server config, providing app-level isolation.

ajayvk··on App-Level Isolation in Web Server Config
Discusses an alternative approach to updating web server routing rules. Multiple apps can be installed, each owns a namespace (domain:path). Within its namespace, the app can update routing rules, without conflicting with any other apps
ajayvk··on Collection: More Doctors Smoke Camels
The "Costlier Tobaccos" tag line looks strange now. Products which want to show sophistication no longer promote the fact that they are more expensive.
ajayvk··on Reimagining OSS Licensing and Commercialization with Fair Source [video]
KubeCon 2024 talk, talks about difference between source code license and distribution license. From description:

Join Adam Jacobs, founder of System Initiative, as he explores an innovative approach to open source software (OSS) licensing and monetization. This session will dive into:

The limitations of traditional OSS licensing models

Introduction to Fair Source licensing and its principles

Balancing open collaboration with sustainable commercialization

Potential impacts on developer communities and business models

Real-world applications and case studies of Fair Source in action

Learn how Fair Source licensing aims to create a middle ground between fully open and proprietary software, potentially reshaping the OSS landscape. This presentation is essential for developers, project maintainers, business leaders, and anyone interested in the future of open source sustainability.

ajayvk··on NonStop discussion around adding Rust to Git
NonStop Kernel (NSK) is the OS for the Tandem hardware which had fault tolerant hardware (dual everything) and software (process pair with checkpoints) https://en.m.wikipedia.org/wiki/Tandem_Computers. The OS is not posix compliant, very different from HP-UX. It is used now mainly in financial systems, competes with IBM mainframes. I used to work on NonStop SQL databases.
ajayvk··on Shell errexit style error handling for glue code
This discusses an error handling mechanism implemented for https://starlark-lang.org/, which combines the benefits of exceptions (conciseness of code) and error return values (control of error behavior)
ajayvk··on Errors and Exceptions: Is there a third option?
Yes, Option type is a special value type.

The solution here is more oriented towards glue code, code which strings together multiple API calls. The attempt is to provide a set -e type error handling for such code.

What I have seen is that some error handling, even if it not perfect, is better than letting errors be ignored.

ajayvk··on Errors and Exceptions: Is there a third option?
This started from a discussion thread at https://news.ycombinator.com/item?id=42368065. Created a new topic since this could apply more generally outside of Starlark
ajayvk··on Starlark Programming Language
I wrote up the approach I used at https://clace.io/blog/errors/, started a discussion at https://news.ycombinator.com/item?id=42370488 since it could apply outside of Starlark also
ajayvk··on Starlark Programming Language
I have been building an internal tools development and deployment platform [1]. It is built in Go, using Starlark for configuration and API business logic.

Starlark has been great to build with. You get the readability of having a simple subset of python, without python's dependency management challenges. It is easily extensible with plugin APIs. Concurrent API performance is great without the python async challenges.

One challenge wrt using Starlark as an general purpose embedded scripting language is that it does not support usual error handling features. There are no exceptions and no multi value return for error values, all errors result in an abort. This works for a config language, where a fail-fast behavior is good. But for a general purpose script, you need more fine grained error handling. Since I am using Starlark for API logic only, I came up with a user definable error handling behavior. This uses thread locals to keep track of error state [2], which might not work for more general purpose scripting use cases.

[1] https://github.com/claceio/clace

[2] https://clace.io/docs/plugins/overview/#automatic-error-hand...

ajayvk··on Dependency management fatigue, or why I ditched React for Go+HTMX+Templ
I have been building a platform https://github.com/claceio/clace for teams to develop Hypermedia based internal tools. One of the main criteria for the technology stack and the feature set has been making sure apps can be maintained easily, after six months and after six years.

Settled on using Go HTML templates, Starlark and HTMX. Go has a great track record of not breaking backward compatibility. Go templates are widely used by ops teams, any breaking changes there will cause ops teams to revolt. Starlark is somewhat widely used by build systems (like Bazel), any breaking changes there will cause build engineers to rise up in arms. The HTMX 1.9 to 2.0 upgrade was also painless, no changes required in my test apps. Only change required was to update the way the websocket extension is resolved.

ajayvk··on Rails is better low code than low code
This is what I am trying to solve for with https://github.com/claceio/clace.

Allow internal tools to be built with regular frameworks, while making it easy to add gitops, SSO, secrets management etc which are required for internal tools.

ajayvk··on I Didn't Need Kubernetes, and You Probably Don't Either
Starlark (python like config language) is used to configure Clace. For containerized apps, python frameworks are supported without a Dockerfile being required. All other languages currently require a user provided Dockerfile, the `container` spec can be used.

I do plan to add specs for other languages. New specs have to be added here https://github.com/claceio/appspecs. New specs can be created locally also in the config, see https://clace.io/docs/develop/#building-apps-from-spec

ajayvk··on I Didn't Need Kubernetes, and You Probably Don't Either
Along those lines, I am building https://github.com/claceio/clace for teams to deploy internal tools. It provides a Cloud Run type interface to run containers, including scaling down to zero. It implements an application server than runs containerized apps.

Since HTMX was mentioned, Clace also makes it easy to build Hypermedia driven apps.

← PreviousPage 2 of 4Next →