Stallion - Build Custom Web Applications

Stallion is a powerful web framework that rivals Rails, Django, or Play. It is batteries included -- it comes with everything from templating to an ORM to authentication framework.

Superb Performance without the Headaches

It is almost impossible to code a slow stallion site. By using the JVM, apps run 10X as fast as languages like Python or Ruby. Furthermore, you can advantage of additional cores. Caching and smart cache expiration is built into the core of the framework.

Built to take advantage of cheap RAM and Cores

Stallion can optionally sync a database table into local memory. This means you never have to write complicated joins just to do simple things in a high performance way.

For example, let us say want to find a list of blog posts in a certain category, and print out their titles along with the author name. The author name is stored in a separate table. If we do a query with a join, we end up returning the same author many times, which is not very performant. If we query for the author for every post, we could end up with hundreds of queries. The optimum way to do it is as follows:

List<Post> posts = Posts.filter("category", "history").all()
          Set ids = List authorIds = posts.stream().map(b -> b.getAuthorId()).collect(Collectors.toSet());
            List authors = Authors.select("id IN ?", Author.class, ids);
              Map authorById = new HashMap();
              for(Author author: authors) {
              authorById.put(author.id, author);
              }
              for(Post book: posts) {
              print("Post %s by %s",
              post.getTitle(),
              authorById.get(book.authorId).getFullName());
              }
      

But in Stallion, if the author table is synced into memory, you can write much simpler code:

for(Post post: Posts.filter('category', 'history').all()) {
          print("Post %s by %s",
          post.getTitle(),
          Authors.forId(book.authorId).getFullName());
          }
      

With other frameworks, the latter would require a database query or memcached lookup for every single post. This incurs the cost of interprocess communication, network latency, and serialization. With Stallion, if the entire table is in RAM, it is simply an ultrafast hash-table look-up.

Stallion uses smart cache-control logic to make sure that your objects are never stale when you need them.

Batteries included

Building a site in django or rails requires stitching together a variety of dependencies, often requiring compiled libraries and complex builds. You'll need memached for caching, celery for tasks, another service for health monitoring, etc.

Stallion comes with everything you need all built in. Running Stallion is as simple as installing Java 1.8 and running a single executable file.

  • Database layer and ORM
  • Templating based on Jinja
  • Caching (using Ehcache)
  • Asynchronous and future scheduled tasks.
  • Recurring jobs (cron replacement)
  • Asset bundling
  • Secure exception reporting and emailing
  • Real-time JSX, Angular, or SASS processing -- no watchers, see your changes instantly
  • Database migrations
  • Zero downtime deploys, with best practices to prevent deploying bad builds.
  • A healthcheck endpoint that monitors every normal cause of outages: excess memory usage, too many 500 errors, disk space, too many open file handles, stuck jobs, stuck scheduled tasks, SSL expiration.
Stallion is still being developed. If you want to know when it is ready for use, give us your email. (We won't spam you, promise):

And in the mean time, read the blog and follow us on Twitter