openrun

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

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.

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.

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.

I am building the https://github.com/claceio/clace project as a platform for teams to deploy internal tools. As part of that, Clace implements an application server which uses containers to deploy any application. AppServers can be much easier to use compared to full-featured container orchestration solutions. AppServers support deployment of stateless applications only. The limited scope means that it can be much easier to configure and use.

https://github.com/claceio/clace is a project I am building for that use case. Run multiple apps on the same machine, Clace acts as an application server which manages containers https://clace.io/blog/appserver/

This is an issue I have had with web projects, especially for internal tools. Without constant maintenance, they reach a state where new changes cannot be done easily. I am building https://github.com/claceio/clace to try and fix this for internal tools. Go, go templates, HTMX, SQLite and Starlark is the stack. A goal is that apps should be easily maintainable after six months and after six years.

https://github.com/claceio/clace is a project I have been building as a way for teams to easily deploy internal tools. As part of that, I added the ability to create simple auto generated UI for backend actions. The goal is to make it easy to develop and deploy automation scripts, instead of using Rundeck or Jenkins to run scripts. Clace is implemented in Go. Starlark (python dialect) is used to configure backed actions. You define the params and what action should run (like run a shell script, run a HTTP API or a database call). Clace will show an auto-generated UI. The UI uses HTMX for interactivity, using OOB swap. The results are shown as text, table, JSON tree or even custom HTML reports. https://utils.demo.clace.io/dict is demo dictionary app (app source is at https://github.com/claceio/apps/blob/main/misc/dictionary/ap...).

I am building the https://github.com/claceio/clace project as a platform for teams to deploy internal tools. As part of that, Clace implements an application server which uses containers to host any application. AppServers can be much easier to use compared to PaaS solutions since they support deployment of stateless applications only.

I am building the https://github.com/claceio/clace project as a platform for teams to deploy internal tools. As part of that, Clace implements an application server which uses containers to host any application. This post talks about why that is useful and how it is different from PaaS solutions.

I have been building https://github.com/claceio/clace, a project which makes it easier to manage web apps for internal use (locally and across a team). SQLite is used to store static files. This post talks about the reasoning behind that.

I created https://github.com/claceio/clace/issues/33 to track this

I have been building the open source project https://github.com/claceio/clace. Clace is an application server that builds and deploys containers, allowing it to manage webapps in any language/framework. Compared to application servers like Nginx Unit, Clace has the advantage of being able to work with any application, without requiring any dependency or packaging changes. Clace provides a blue-green staged deployment model for apps. Not just code changes, even configuration changes are staged and can be verified before being made live. Clace is not a PaaS solution, it does not support deploying databases and other auxiliary services. It does share the fact that it manages containers with PaaS solutions. Clace is different in that it builds its own reverse proxy, instead of depending on Traefik/Nginx. This allows Clace to implement feature

I am building Clace https://github.com/claceio/clace, an app server for containerized applications. The goal is to build something like Nginx Unit, but supporting any language/framework. Each app runs in a separate container. App updates are done using a blue-green staged deployment. Clace already supports most python based apps (wsgi or asgi), any other language works with a custom Dockerfile. Plan to add support for automatically shutting down idle containers, allowing for scaling down to zero for each app.

I love the minimal approach - will try it! There is also: https://kamal-deploy.org/ https://github.com/basecamp/kamal https://dokku.com/ https://github.com/dokku/dokku/ https://clace.io/ https://github.com/claceio/clace