Web frameworks – which less popular frameworks are you using and why?

I've tried FastAPI recently, as the idea matured, I came to regret the decison. It's not bad, in fact it was very pleasant to get started with, yet I found myself missing and reinventing the wheel as compared to django. I develop with Django since 2015 (1.6 or so), to me it is the goto for any web related project.

I used to think my distaste for new and upcoming Javascript frameworks is a sign of getting old and not being as adaptable as I used to. But nowadays my thinking has shifted to seeing it as a instant loss of productivity with little upside.

Just like musicians don't switch instruments every time they see something shiny. Neither should we, or at least without feeling guilty about it. Mastery takes time.

I've been looking into Remix (https://remix.run/) to build javascript web project. I come from 10 years of Python/Django background and I want to avoid complexity of frameworks such as React particularly the headache of state management.

Remix seems to use an approach similar to Hotwire Turbo Frames and a syntax of React JSX. This allows creating composable pages and loading partials in a page while still being able to create React components.

The main use case for me is web3 where almost all libraries are in Javascript. And I want to have the least friction for this move. It basically encapsulates the server and client side of an HTTP request in a single component and handles the json parsing operations under the hood.

You can argue that it might not necessary and a template engine can come much handier. I believe NestJS handles that but if you need the React JSX and reusable components it can be quite practical.

Ruby: Roda

From the author of the Sequel gem. It can do everything that Rails can, faster and lighter by order of magnitude, expandable (turn on only the plugins you need), and it does it all 'the Ruby way', not 'the Rails way'. That means simplicity, clarity and power. Generally, all software Jeremy Evans releases is of excellent quality and actively supported. Oh, and this Roda framework is in active use by the US government and is subject to regular security audits...

The definition of obscure but powerful and quite beautiful web framework.

It's been a long time since I wrote any PHP in anger but back when I did, I got a ton of mileage out of CodeIgniter (https://codeigniter.com/). It looks like it's still around and being actively maintained. I can quite clearly remember a number of projects that went from being just an idea to 90% functional in the span of an evening.

I write Python almost exclusively now, but still pine for something like CodeIgniter. Flask is nice because it lets you bolt on whatever you want, but you spend a lot of time choosing, prototyping, and often discarding libraries. Django does a lot of heavy lifting but has (IMO) a very steep learning curve. There doesn't seem to be anything (or at least anything I've liked) in between.

I'm still building most projects using Spring Boot and Kotlin. While Spring can probably be classified as a popular framework for the Java language I don't see it being used a lot in combination with Kotlin.

For me personally it's a very productive framework for backend APIs or web projects with server side templating with Thymeleaf as the template engine.

My setup combines the flexibility/configuration/productivity of Spring Boot (and the full JVM library ecosystem) with the modern language features and ergonomics of Kotlin.

I keep things simple in most of my projects. No reactive/coroutines/graalvm. One-thread-per-request blocking model is good enough for most of my use cases. Annotation based DI and configuration.

Javascript: SvelteJS

Using it for some personal projects with Vite and it is a breath of fresh air. I use React for work during the day, but coding in Svelte just brings me joy.

Elm, with Typescript and Vite.

Working with Elm code is satisfying to me. It's generally easy to revisit code I last worked with months ago and get immediately fluent with it again. The "Elm Architecture" (model / update / view) with all external interaction done over "ports" is so clean (albeit with boilerplate). Integrating with JS libraries has to be done over ports (async one-way messaging) but it works well enough in practice. Vite provides a decent dev/build toolchain with hot-reloading of all Elm, JS, and CSS code. The Elm framework is very opinionated and has stopped evolving, but it's mostly a joy to work with.

Golang, Fiber.io framework, Go Templates, and some AlpineJS.

Why: No JS build toolchain hell, tight control over dependencies (you know because software supply chain), blazing speed, really nice live editing of go templates without server restarts, fully supportive of the browser's back/forward cache, and a single binary to deploy (plus the templates, CSS, etc.). Simpler DevOpsLife!

For SPAs I still use Backbone.js... Yes, I know, 2014 called and it wants its framework back. But... I like it. It's lightweight and doesn't impose any particular style or philosophy. It's well suited to small projects.

On the back end, for small projects, using a full-fledged framework is usually overkill. Writing a simple API that reads and write normalized data is quite trivial, and when one is writing everything it's easier to understand what's going on.

By this I mean that some behaviors come from the framework and can sometimes surprise you. For example, in Backbone, change events on the model are triggered not when an instance is updated, but only if the new version is different from the old. This makes sense, but the problem is that the comparison is only done on a shallow level. When updating deep properties, no change event is triggered. This took me some time to figure out.

Light frameworks have fewer unexpected behaviors, by virtue of being small.

This is a self-plug, but I use the (commercial) framework that I wrote: Nodewood [1].

I really enjoy JavaScript, specifically the combination of Express on the back-end and Vue on the front-end, and I got tired of having to do so much setup every time I wanted to work on a new project. So I abstracted it out into its own thing and started adding fixes to all the other little things that bothered me about web development, like having to write validation & business logic on the front-end and back-end instead of being able to use shared code, having to manually migrate Stripe products, etc.

I've been working on adding a deploy solution based on Pulumi [2] in the last few days to finally finish out the 1.0 feature set, which will mark a pretty exciting milestone in a several years-long journey!

---

[1] https://nodewood.com/

[2] https://www.pulumi.com/

TypeScript: Nestjs

If you have used a good batteries included MVC like Django before, you’ll feel at home. I made a production ready app in a few weeks with it and Prisma as ORM, that’s been the base of our startup and served us wonderfully. Can’t recommend it enough, as it is really powerful and is very extensible and as obvious by the number of plugins and examples available.

I use http://rivetsjs.com/ in a production intranet project. At the time I started using it I wanted a lightweight alternative to angular/vuejs. I didn’t want the junior devs at the customer to have to learn webpack, etc, but I did want two way data binding, and wanted as lightweight as possible. It has met those needs, and more - it supports creating web components so has let me do reusable code bits also. My main gripe is it’s somewhat stagnant, and there isn’t the ecosystem of components and help like vue or angular.

Still, I’d recommend it for small projects where you need binding.

Wt(pronounced as Witty)[0]. The developers like to call it "toolkit" instead of framework. It is a very interesting take on developing web applications; it is inspired by Qt(pronounced as Cute). The idea behind Wt is that web app development should be similar to desktop app development. It is targeted towards C++ and embedded developers, but if you look at their examples page[1], and their code examples in the "examples" directory of the source code, it is not limited to embedded platforms. The company behind this project is Belgian and their web site[2] is also developed using Wt :)

[0] https://www.webtoolkit.eu (their complete website is built using Wt)

[1] https://www.webtoolkit.eu/widgets

[2] https://www.emweb.be

Having a really good time with both Flutter (Dart) and Lit (JS/TS Web Components) the past few months. Strongly would recommend both assuming you pick the right one for the right thing (I.e Flutter not well suited to entire classes of projects)

Both are doing some really cool forward thinking stuff, both have excellent developer experience and both are still currently not particularly popular on the web but expect them to both be huge in the next couple of years.

I have used Jekyll for over a decade, but for the next iteration of my static personal homepage I am using: POSIX make, POSIX sh, POSIX sed, and tidy. Considering adding POSIX awk to generate a small portion of the HTML from tsv. Also not overly happy about tidy (it is difficult to control its level of output [1]), so I may look for a replacement.

[1]: https://github.com/htacg/tidy-html5/issues/996

Why? I have been on a bit of a minimalist streak recently and I wanted to see if I could keep things simple and as close to treating it all as text as possible. So far I have to say that it feels refreshing and trying to come up with simple solutions has made me feel much more motivated to get coding.

I've been using Python's Tornado (http://www.tornadoweb.org/) for years now.

Now on version 6, it's fast, well maintained, mature, and has good docs with readable code.

@bdarnell has done an excellent job maintaining it.

Here's one example:

Tornado supported async style coroutines before asyncio was a thing. Now it uses asyncio under the hood by default -- and it did so with an exceptionally smooth transition.

Play Framework: Built on top of Akka, non-blocking architecture (offload any long-running work into Futures), mature codebase and APIs for Java and Scala. It's an opinionated framework where you'll write your code in a classical MVC style (define endpoints in a routes file which are then handled by controllers).

http4s: Focused on functional programming, more of a library than a framework. Doesn't define the architecture of your program as much as Play and can therefore be integrated into your project more easily if you want to add HTTP to an existing project.

I enjoy working with either of these two. Pick Play if you want a framework (contains everything to get going with HTTP but forces a certain architecture). Pick http4s if you want a library and/or more focus on functional programming.

Elixir: Phoenix Framework.

I don't think I've ever had so much _fun_ writing a web app before :)

SBCL with hunchentoot. My colleague started work on a side project in this stack and now we are trying to make it into a proper production application within our organization. I am climbing some learning curves at the same time, emacs, lisp, several packages... Fun times!!!

PHP - I found new love for

1) Nette https://nette.org/en/

2) Phalcon https://phalcon.io/en-us

If you agree, we should talk :)

oh u want obscure?

Java: Play 1 https://www.playframework.com/documentation/1.5.x/guide1

JavaScript: lol, no, https://htmx.org and https://hyperscript.org

likes: Play 1 is a pretty good JVM take on Rails, a little too much bytecode magic for my tastes, but still very low friction

htmx and hyperscript are my own babies. htmx improves the expressiveness of HTML and hyperscript is a reinterpretation of HyperTalk for the web. I am not objective about it, obviously, but I do love working with them: I think they keep the web the web in a way most other approaches don't.

dislikes: Play 1 is really old and is barely supported. htmx and hyperscript are both written by a lunatic I don't really like sometimes.

PHP - Aura, there’s not a ton of features being added these days but it doesn’t need them. Nice set of components, you just choose what you actually need.

JS - I still have a tiny bit of MooTools in production because I have found some more complex animations nearly impossible to port to pure css without resorting to horrible hacks. It really had an amazing animation “Fx” toolkit, but given it’s nature of prototype pollution, it design as essentially a patch to the language rather than a framework, you really should not use it these days.

I'm using Mapless [1] for persistency in Smalltalk. And Svelte for a multi-platform frontend app I'm working on [2]. It's a local or remote native Smalltalk IDE.

[1] https://github.com/sebastianconcept/Mapless [2] https://github.com/sebastianconcept/lobster-ui

PHP: CakePHP

This was the very first framework I learned when I first learned PHP, and it has always just been so incredibly _easy_ to accomplish most common MVC tasks that I've stuck with it. I've become quite the expert in the framework over the years, even managing to make it bend quirky ways that it was not meant to in service of business goals. That has made me an extremely valuable resource for companies using the framework, and so I keep using it. Plus, I enjoy it immensely.

My org is heavily invested in Ember and it sucks. We're into it for purely historical purposes. It was chosen by devs 2 generations past. It's not a terrible framework conceptually, but being invested in anything niche or out of fashion is such a burden. No one knows how it works, can't hire for it, updates are rare, hard to find integrations. I would not venture outside the mainstream if you can't afford to take big risks.

Haskell: IHP / Thin

Because it's the only Haskell web framework I know about;)

JS: Sveltekit, Astro.build

Sveltekit for web apps because it's insanely well build & ships compiled JS code instead of a large lib like most big contenders do.

Astro for websites because it doesn't force you into any frontend frameworks (you can use Svelte, Vue, React) and focuses on static sites + partial hydration. Awesome for web performance / SEO!

Python: FastApi

Fastest way to build fast APIs with Python.

When I worked at the BBC I was working on their notifications widget in the top nav bar. This would live above the fold on every BBC site, including News, Weather, iPlayer, Sport, etc. Therefore it had to be extremely small in bundle size, but I still wanted something nice and component-based so the code resembled something modern at least.

I ended up choosing Riot.js. Worked pretty nicely for the niche task I had for it.

I am really, really, REALLY surprised so few people talk about Quasar https://quasar.dev/

Quoting from their website [1]:

"Quasar [...] is an MIT licensed open-source Vue.js based framework, which allows you as a web developer to quickly create responsive++ websites/apps in many flavours:

SPAs (Single Page App)

SSR (Server-side Rendered App) (+ optional PWA client takeover)

PWAs (Progressive Web App)

BEX (Browser Extension)

Mobile Apps (Android, iOS, …) through Cordova or Capacitor

Multi-platform Desktop Apps (using Electron)

Quasar’s motto is: write code once and simultaneously deploy it as a website, a Mobile App and/or an Electron App. Yes, one codebase for all of them, helping you develop an app in record time by using a state-of-the-art CLI and backed by best-practice, blazing fast Quasar web components."

Using it for a few years now I must say that it always impresses me with its completeness and high quality documentation. Cannot recommend it enough.

[1] https://quasar.dev/introduction-to-quasar

I wrote one (very opinionated) in C# ASP.NET a long time ago (14 years or so and since ported to all versions of .net core besides 6) because I hated the plumbing I had to do with most options in the space. 4 years ago, I started a large project and I was pushed to use vanilla asp.net with the promise that things were better now. Unfortunately I miss my own framework now all the time; it would let you focus on the logic and your core strengths. I had to create data models and logic and the framework would give me frontends (mobile, desktop and web) and api’s, with auth etc without me having to think about it. Then a frontend person had a working system they could fix the frontends for without touching the logic etc. I added, in 2017, micro services which, without having you to think too much about them, allowed you to point out which namespaces you want run seperately. And deployment (on aws, azure and alicloud) was all automated.

If I find the time, I will clean it up and open source it. And for side projects I will use it again.

Rust: Warp.

I like Warp because it's akin to a layer on top of Hyper (for HTTP) and Tokio (for async), and can go down into these deeper layers as you wish.

I'm using Warp now because I'm trying all the Rust web frameworks. I like Rust Actix for larger production projects that favor a more-long-term ecosystem. I like Rust Rocket for its user-friendly ideas and superb tutorials for onboarding.

I haven't touched it in a year or so, but I really enjoyed using EmberJS over the other frontend frameworks I've used. One reason is that it attempts to be a kitchen sink framework. In the React ecosystem you have to piece together your own framework, which is cool if you have the time to evaluate each piece and glue it on to your project. But Ember comes with pretty much everything you need -- routing, state management, testing, temolating, etc -- straight out of the box. And the update cycle was nice for an organization to follow for reliable maintenance.

Obviously, it comes with constraints. You can't really swap out parts/libraries if you find a better one to suit some need. And you can't really stray too far from the beaten path; you have to do things The Ember Way. But the consistency and organization made for a really nice developer experience.

Also, I found the community really friendly and welcoming, which has not been my experience in the wider JS world.

Just PHP.

Plain old JavaScript.

Bootstrap for CSS/HTML tho.

Maybe I’m old, but learning frameworks doesn’t speed up or simplify anything for me.

I've been having a blast using Roda, a Ruby web toolkit. It's an established project, certainly not new, yet somehow it feels really fresh and more in line with minimalist JS frameworks that have become in vogue. The plugin architecture is pretty sweet.

http://roda.jeremyevans.net

I use Pedestal (pedestal.io) because of:

1) Clojure is a superpower

2) Interceptor-based approach (think: dynamic middlewares) works really well and it’s flexible.

Clojure has no “frameworks”, but Pedestal has all the batteries I need included.

I used Cappuccino for a couple apps years ago. It used Objective-J which was roughly Objective-C on top of JavaScript. It was essentially Mac OS Cocoa in the browser. Even much of Apple’s Cocoa documentation was useful for Cappuccino.

https://www.cappuccino.dev/

I feel like the deeper I get into my craft as a software engineer the less I use frameworks.

Now it’s more about applying certain principles, such as CA and preferring simplicity over dependencies.

I’ve tried some web frameworks and found them easy to get started with but they carry so much bloat and unnecessary cruft.

It’s way easier for me to consider my code responsibilities and build simple software that is easy to test, painless to maintain, and finally simple enough for anyone new (or a newbie) to pick up with what they know, without having to learn the nuances of the framework.

With that said I’ll say my favorite popular framework is phoenix. I was studying elixir five years ago and used phoenix to build a few simple apps. Great community and documentation.

Kotlin: Javalin

Backend app boiler plate [dependencies] already setup for anyone wanting to build backends in kotlin

git clone https://gitlab.com/asad-awadia/kotlin-server-app.git

Anyone have a suggestion for a JS/TS based framework where you manipulate the DOM by ID instead of generating HTML?

I work on a small custom site that has a particular workflow - a HTML/CSS guru creates the very-custom pages (no two are alike) in Webflow, then I jetpack in at the end and hook up the dynamic bits. My work is 90% hiding/showing elements and filling in text.

Anyone have suggestions for this kind of workflow, where the HTML is the source of truth about the layout/structure and I just fill in the data? The goal of the workflow is to allow the HTML guru to complete their portion + get it reviewed without eng help, and minimize the coordination needed between HTML and eng.

For PHP, been using F3 (https://fatfreeframework.com/3.8/home) for a long time. It light and gets things done fast. Even made a CMS out of it.

We use prime-mvc, a lightweight Java MVC framework: https://github.com/prime-framework/

I think this framework grew out of the initial development team's needs for a fast, lightweight Java framework. (I wasn't there, not sure how much looking around they did, but this was years and years ago.) It's now foundational for our applications.

We've had some folks at the Boulder Ruby meetup present on Hanami, which appears to have better separation of concerns and testability as well as less magic than ruby on rails. Hard to compete with the ecosystem, though.

Scala: Akka-Http

If you want something that scales out horizontally akka-http + an distributed akka stack (cluster, sharding, etc) works beautifully. Especially pairing it with websockets/grpc streaming, you can end-to-end stream pretty effortlessly.

I've been using ForgoJS ( https://forgojs.org/ ) over the past year, and have become a maintainer on the project.

I like it because it just gets out of my way. I get declarative DOM updates like in React, but without any heavy-handed idioms, behavior that's tricky to understand, or subtle footguns.

It feels more like using a library than integrating with a framework. Most of my code is just boring variables and function calls, as if I have a simple declarative layer between me and the DOM but I'm otherwise writing vanilla JS/TS.

Pyramid: It's a mid-tier web framework for Python. It's more modular and less opinionated than Django, has more batteries included than Flask, and works without issue with PyPy. Its predecessor, Pylons, was used to develop the original version of Reddit. It's documentation can be sparse in some areas, but it has many examples and tutorials, and the code base isn't terrible when you need to dig into implementation details. I use it for my employer's website and many internal web apps.

PHP: My own, so not known by anyone else ;)

I made it because I don't like all the existing frameworks. That said, it uses Laminas Diactoros because not using that would be to reinvent the wheel.

my backend is an object storage server that has features such as user and group management (including messaging between users), object level access control, and much more. it has all the features that i can think of for any kind of CRUD application. originally published under the name open-sTeam, i effectively took over its maintenance under the name societyserver when the original developers stopped working on it. i fitted it with a REST API so i can build javascript frontends for it.

for frontends i currently use aurelia.

my first frontend framework was angularjs, which i choose before it was popular, as it what i felt was the best framework at the time.

when angularjs started showing its age i looked around for alternatives and found aurelia. other alternatives at the time were react, vuejs and angular 2. aurelia is much more standards oriented, and cleanly separates templates and code, which is something i value, and which is one reason to reject vue. likewise angular 2 felt overloaded with its custom syntax and parsing mechanism. react felt way to different and just didn't seem attractive.

i will stick with aurelia until i get to a point where it doesn't let me build what i want/need, and only then will i look for alternatives.

i used django and odoo previously. now i am working on a project that uses a new common lisp web framework gui called clog [0]. it is websocket based so singlr page applications are no problem. it is awesome because it is very flexible and common lisp has unrivaled repl driven development

[0] https://github.com/rabbibotton/clog

Perl: Mojolicious (https://www.mojolicious.org/), Dancer2

Self-plug: I wrote this Node / TypeScript port of "clean architecture" to typed, functional JavaScript two years ago - and it's served me well on every production project ever since

https://github.com/jbreckmckye/node-typescript-architecture

I have built my website: https://leloew.com/ with FastAPI and Jinja. I love building Apis with FasApi, as a web framework it is missing a lot of features you would get from Django. However, I don't like Django's Object oriented approach.

Used mithril.js and really love it albeit that was a few years back so not sure of it's current state.

Rust: actix-web

It was mired in controversy a while back but now it's one of the most feature complete frameworks available. I've been following the book zero2prod.com which implements an API service via actix-web as a way to learn Rust and backend web development in general, which is nice.

I use Fiber (https://github.com/gofiber/fiber) for APIs and SolidJS (https://www.solidjs.com) for web UIs.

Typescript: Sveltekit + Supabase

Svelte is king in DX, development velocity, and quality for the vast majority of web projects. I can build a JAMStack website in a day and an app in a week.

If I had to use something else, I would reach for Astro for static sites and the latest version of Nuxt for an app.

Switching to Elixir/Erlang: Phoenix for my side-projects.

I've been using Django for the past 2 years now.

Go: Ent - I tried every option for getting typed db access with Postgres, and Ent blew me away. It has scaled nicely both from a code standpoint and performance. The team behind it are very active in Slack and all round nice people.

I build thousands of static pages with kotlinx.html. Suits me best because I can use all the features or my favorite language. That might be an advise in general: find out if your favorite language(s) has a decent web framework

PHP: usually you only need routing, not the whole kitchen sink; check out slim.

I use Bottle [1] a lot for toy projects.

[1] http://bottlepy.org/docs/dev/

feathersjs. It is a very flexible, modular and scalable framework. It has good documentation. and it solves everything quite simply, no unnecessary complexity.

Out of curiosity, which is the best framework to learn in 2022?

a) Python-Django? b) Ruby? c) Other?

I already know python, and I would like to learn a framework to build MVC's for startups!

Still have some production code running in ColdFusion (using the open source variant, Lucee) on an older framework, FW/1.

https://www.lucee.org/

https://framework-one.github.io/documentation/

Tangentially related: Is there any "framework" that simply loads a webassembly executable and then has it directly manipulate the entire web page being displayed to the user by the browser ? Presumably while keeping a websocket open to the server host.

Roda (Ruby) for webhook processing.

JavaScript: AdonisJS

Arguably the first JS equivalent of web development frameworks such as Laravel/Rails

I'm a huge fan of feathersjs and I don't even use the websocket features.

What?? Nobody wants to mention redwoodJS? CMON now... it's the up n coming framework to rule them all!!! FullStack... JAMSTACK baby!!! What else could you possibly want??

Giraffe -F# Functional framework built on top of ASP.NET.

Bottlepy. I look for minimalism and "frameworks" that work more like libraries than actual frameworks.

PHP: I think you need to add Symfony to your list

I use PHP-is-a-framework PHP :-) Fast, light and easy.

I use the Laminas Framework (formerly known as the Zend Framework) for coding in PHP.

For Kotlin, there's http4k. It just gets out of your way.

-Nitrogen, Nova and Zotonic (because erlang)