What's is your go to toolset for simple front end development?

Ignore any recommendation of React, TypeScript, Vite, or Tailwind. Here are some recommendations that don't require NPM/Node.

Pick a "classless" CSS library from a site like CSSBed[1]. These are kind of like Bootstrap, except you don't need to write any CSS or apply any CSS classes in your HTML for them to work. No tooling necessary; just include a tag in your HTML document. If you'd like to try something similar to this "Tailwind" hotness everyone keeps talking about, try Basscss[2]. Again, no tooling, just need a tag.

Once you start needing to add interactivity to your site, htmx[3] is nice and decently simple. If you really want something React-like, Mithril.js[4] is very similar but much simpler.

[1] https://www.cssbed.com/

[2] https://basscss.com/

[3] https://htmx.org/

[4] https://mithril.js.org/

If you need any kind of interactivity on the frontend, but are more comfortable with the backend, I would suggest looking at Phoenix LiveView [0] or a similar server-rendered HTML technology for your language of your choice [1].

In short, these solutions take JavaScript out of the mix entirely and basically let you deal with a single logical "app", rather than a separate frontend & backend.

[0] https://github.com/phoenixframework/phoenix_live_view [1] https://github.com/dbohdan/liveviews

I just read that you didn't want to troubleshoot html, css and js, so my goto toolkit for simple UIs might not fit your bill, but hear me out :)

At work, when I do internal tools, they are usually well received. They also pass just below the threshold of having their looks be judged. They're not ugly, because they're almost not there.

Very plain HTML: HEAD+TITLE, H1, H2, UL, OL, A, IMG, INPUT, BR, TABLE, P Javascript as needed, usually embedded in the HEAD There is no CSS.

There's simply no design to attack, no colors or alignments to disagree with. It exposes the interface to communicate with the backend, nothing more.

It's also the fastest and simplest way of getting stuff done, if you don't need to expose it to "end users".

Man, given all the comments suggesting frameworks that will require you to do html/css/js it seems like no one has really read your post.

For your use case I would look at AppSmith (https://github.com/appsmithorg/appsmith) or ToolJet (https://github.com/ToolJet/ToolJet).

These are full-stack low-code frameworks, but it's easy to use them to do just the frontend and connect to a backend API you implement yourself separately.

Edit: forgot to mention that these support drag&drop for building user interfaces :)

https://svelte.dev/tutorial/basics - easy to get started with but really powerful for complex stuff too

For layout, don't use any CSS framework, but instead refer to https://css-tricks.com/snippets/css/a-guide-to-flexbox/ often - every time I use some big CSS framework I end up fighting it at some point.

https://vitejs.dev/ for packaging - I got really grumpy when frontend stuff started needing build and packaging tools, but it's the nature of things so you just have to deal with it, and vite is fast, not overly complicated, and supports fast hot reloading.

Preact [0] + htm [1]

Why? Preact is small, fast, and reasonably easy to use. But the main selling point for me was that, together with htm, I don't need any build system a la webpack. No node_modules folder. I just have to load one script (preact + htm bundled), define my components in plain javascript files and import them. Bliss for me.

[0] https://preactjs.com/

[1] https://github.com/developit/htm

Edit: Just read that you want drag & drop style UI building, so this might not be for you.

I started off like you on the backend development. When I had to build small webapps, I looked at the various frameworks and then settled on KnockoutJS. KnockoutJS is a very small and simple JS library. This is several years ago and at that time I didn't even know Javascript. The reason I say that is because even for a JS newbie, the KnockoutJS library was simple to use. (I read somewhere that MS Azure used KnockoutJS for their frontend dashboards in their earlier version. Not sure if they still do.)

If you are comfortable with plain HTML + CSS + Javascript, adding KnockoutJS will give you a minimal app building capability that you will find useful for several usecases.

You get to manage your application's data model in javascript on the client side and the UI can be bound to your datamodel (bidirectionally) without having to manage it yourself. That is more than sufficient for many usecases.

If you don't want to be fiddling around with CSS too much, you can use something like Bootstrap or Material Design's CSS templates to get some decent looking UI (without getting lost in CSS minutiae).

For your development workflow, start without any bundler (like WebPack or Parcel) first. Once, you have your application working, you can then introduce it as a final step.

Sveltekit with typescript and adapter-static.

Sveltekit scales down very well: if you need only CSS and HTML for some paths, that's all you write in your svelte files, and that's also all users download. At the same time if for some other paths you need more Javascript, you can just add it there, without bloating the JS bundle size. Svelte's built-in stores makes it also possible to also do very complex state management, if that's ever a need. With vite under the hood the dev experience is lightning fast.

I use AlpineJS for reactivity. Along with JS Template literals[1], I can reach quite close to the ergonomics of having react like re-usable functional components without bringing in the whole complexity of react ecosystem. Works quite well for smallish projects.

For styling I pick up Bulma CSS if I need some more complex components (tabs, modals etc.) or TailWind if I just want to pepper a little styling here and there. All this loaded directly from CDN. No build step, no server etc required. You easily do debugging from browser console.

I have made a few internal tools like this which my co workers use everyday.

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Not drag and drop style block building, but:

1. https://htmx.org

2. https://simplecss.org

I've been doing this for so long that I've gained years of experience in React, Angular, and Vue. You said simple front-end development and there's nothing easier than Vue, hands down. The syntax is so easy and segregated perfectly; no JSX wild-west ugliness or fucking with a minefield of observable and subscriber pipe functions. It's easy to get started, encourages clean code, and very readable. It boggles my mind how there's so few VueJS jobs available despite the advantage. I think part of it is just developer laziness in picking up yet another library, which I totally understand. Unfortunately I'm stuck in React and Angular land 90% of the time and hate it.

Honestly? React [0], Tailwind [1] and Vite [2]. Using Vite so setup the environment and tailwind components for css I have never been able to create front end faster than now. It feels like a super power.

[0] https://reactjs.org/

[1] https://tailwindcss.com/

[2] https://vitejs.dev/

> I'm quite firmly in back end development.

What languages / platforms are you familiar with?

For example, if you do a lot of C#, you could look at Blazor. Server-side Blazor isn't 100% simple; but if you're already doing C#, it's very easy to learn. (In-browser Blazor compilers C# to WASM, Server-side Blazor sends all mouse clicks over a websocket and gets back partial HTML updates. It (server-side) has a bit of latency, but because all state is in the server, you can keep your implementation simple.)

There's also a similar thing for Java, but I can't remember the name at the moment.

* Bootstrap 5 for CSS and customized styling: https://getbootstrap.com/

* HTMX (formerly "Intercooler") for interactive (Ajax) functionality: https://htmx.org/

How simple are we talking about when you say "simple frontend development"?

For simple personal projects I write all my own HTML and CSS from scratch. It's not particularly hard to write stuff with low to moderate interactivity from scratch and the infrequency that I do frontend dev means it's quicker to do that than learn whatever new framework has replaced the deprecated one I spent time learning a couple of years earlier (that's probably unfairly snarky but from an outsider looking in, it's hugely daunting and depressing when you see just how much churn there is).

The only problem with rolling your own is that you raise the difficulty for anyone new joining the project (if it's something you plan on opening up to other contributors) and CSS can be a bit a of trial and error to get right too.

However if you're just writing a few test UIs to interface with backend APIs you're POCing (which is what your question reads as) then it's probably easier to skip all the other frameworks out there and knock up something yourself.

For home-lab/internal UIs, you can go a long way with the auto-generated model-admin pages from Django. If you just need CRUD and actions triggered on a list of models, you can typically avoid any UI work and just define a few Admin classes, and if you need to make custom forms it's quite easy using Django's templating machinery to override individual pages.

https://docs.djangoproject.com/en/4.0/ref/contrib/admin/

A similar modular admin system that's more generic is https://www.forestadmin.com/, I think this one has a layout editor too. But that one requires a REST API and so it may require more plumbing, depending on what you've already built. Or it could fit nicely on top of what you already have, if you already have APIs for everything.

React with create-react-app [0] and Netlify for deployment, github as git repo. This way you can have a hello world app that has a full CI pipeline in ~30 mins.

[0] https://reactjs.org/docs/create-a-new-react-app.html#create-...

Take a look at Pinegrow [0] (I'm the author). It is a desktop app that lets you visually work with standard HTML & CSS files and supports frameworks such as Bootstrap, Tailwind CSS or just plain old CSS. There are also more advanced features, for example live SASS compilation, components, interactions and even exporting WordPress themes and blocks.

[0] https://pinegrow.com

One single piece of CSS instantly improves the look of plain html pages:

  body {font-family:sans-serif;}

Beyond that, all other CSS is optional imho.

And you don't need JavaScript to trigger back-end events, as a simple link will work just as nicely.

I often use plain HTML and a classless CSS (e.g. Water.css[0]) for personal projects.

This way it's easy to write and maintain. Looks okay. Fast feedback cycle during development. No need for build steps. Works in browsers without JavaScript. Works well on desktop and mobile devices.

Highly recommended if suits your needs.

[0]: https://watercss.kognise.dev/

I really like the ultra simple approach of MVP.css (https://andybrewer.github.io/mvp/). It looks better than no styling at all and doesn't require me to get into Bootstrap. Only minimal html tags needed. Perfect for small side projects.

Bootstrap is 100% the answer. Pulling in everything from a CDN is the easiest route.

Bootswatch is also great if you want a little more styling. (Free bootstrap themes)

Bootstrap is great because it is so ubiquitous. They have page templates you can copy to get the page layout you want and then there are tons of bootstrap examples you can just copy and paste.

It's hard to know exactly what you mean by "simple", but I'm fairly sure you want to avoid any frameworks, as those tend to have a learning curve, even for the easiest ones. Same goes for build tools like Webpack, which I still have trouble with after years of use.

For CSS I see a lot of recommendations for "classless" libraries, which I've never tried, but could be good if you don't need to do much tinkering. For just a little bit more time investment you can get a lot more options with something like Bootstrap. It's pretty easy to learn, has a lot of "drag and drop" style components, and there are tons of templates out there (free and premium). I learned it once many years ago and have been using it for projects ever since.

On the interactivity side it really depends on what your needs are, but if you don't need too many bells and whistles you could probably get by with vanilla Javascript. jQuery is also a good choice for simple applications, as it offers a slightly more intuitive interface to some of the basic JS actions.

All of this being said, if you think you will be spending a lot of time on the frontend, or have complex interactivity needs, it might be worth it to learn a framework. I can recommend Vue as one that is fairly easy to get started with and also scalable to larger applications.

I use vuejs with create-vue for scaffolding. And then, google my way through.

Vue is easier to learn and uses html, css and js. So I feel right at home. Forms are particularly easier and vue dev tools help a lot in debugging.

Also, last year, I used it for an app after a break of 3+ years. I was still able to re-use a lot of prior knowledge (even if it was half forgotten). There was new syntax(comp api) and typescript introduced, but older syntax (options api) worked fine.

Pyramid for backend. HTML+css for the front end. Often just bootstrap. Vuejs applied to very specific places that need to be interactive, but without any build/bundling/whatever - just referencing a single minified file.

This thread is amazing. Every other comment mentions a new tool I've never heard of. And I thought building APIs is hard. Ignorance is bliss

HTML, plain CSS, vanilla JavaScript to fetch data / interactivity when required.

mod_perl / PostgreSQL on the back end. HTML::Mason for templates.

I made http://divjoy.com, which lets you assemble blocks into a multi-page web app and then export as a React/Node codebase. Works best if you want the backend in Node, but you can swap out for your own API.

Elm.

If there is a back-end API with a spec (GraphQL or OpenAPIv3) you can generate an Elm client for that which makes API calls type-safe and thus very robust.

https://tailwindui.com/ - lots of pre-made templates using tailwind css. Some are free, but the more advanced ones require payment.

HTML + CSS + JS, if really needed

Since you like Python and want a turnkey React/Python integration with a Django backend, check out https://www.reactivated.io.

It's not drag and drop, but abstracts away all tooling and let's just get to just writing your code. Either in React or in Django templates.

Eventually, if you have any dynamic behavior, you're going to end up rebuilding a lot of what React does for you.

Full disclosure: I'm the creator.

I've run the gamut recently trying to find one that was suitable for a project of mine—nothing crazy, just a server-rendered front end for a CMS/other data source.

It was a mind-numbing exercise I wouldn't recommend. There are a lot of strong tools out there, but they're often billed as 'general-purpose' when they're most certainly not.

For my project in question I ended up getting frustrated with either issues with SSR-rendered stylesheets or runtime access to browser API's and so on so I just wrote a simple server with Express that just renders static pages using EJS as a view engine.

I keep my client in the same source folder, with a different config for the build that drops the artifact in the public.

Since I personally like TypeScript over not using it, there was some build setup—but just `tsc` for the server code and `parcel` for the client code.

There's little configuration, and I had it up and running with hot reloading of both the server and client code in no time—made me regret my decision to audit so many other options.

TDLR:

The client code I decided to stick with "vanilla" JS via TypeScript using parcel to build and bundle deps.

The CSS is just css, but I might replace that with SASS because it can be a touch easier to organize and namespace things.

FWIW, if I didn't want the TypeScript or dependency bundling (via NPM for fetching the code to host locally), it would be just JS and CSS with server-rendered HTML... if I need something fancy I have the option of plugging in a framework or something later. Starting light feels so good...

Definitely agree with other answers that you should look into classless CSS frameworks. You can see a list of popular options here: https://www.designinspiration.info/classless-css-frameworks/

You can get pretty far with just HTML and dropping in any one of those CSS frameworks.

Since you’re using Flask, I would just make some endpoints that serve HTML using Jinja2 templates. Depending on what you’re doing, you might not need JavaScript at all. You can trigger backend stuff using HTML forms with form actions. And with a classless CSS library, the form should look nice too.

If for some reason you want to keep the front end totally separate from the back end, a good framework for building web apps is Remix: https://remix.run/ . It makes it easy to build highly performant websites and has nice helpers for data loading and actions. I also like that it keeps client side JavaScript to a minimum, which keeps things simple and makes your website faster.

htmx (https://htmx.org/) in backend templates (flask would work) and tailwindcss (https://tailwindcss.com/) and you can get very far without touching css and Javascript. Html writing would still be needed.

I am in a similar situation as you (with the addition that I am an amateur dev).

I use either Quasar, a Vue3 framework (vue it's very easy to learn and quasar does all the heavy lifting, plus has plenty of components), or recently Vite with Tailwind CSS (this allows you to better control the style).

I would recommend to study with an empty Quasar project and build from there.

It's not purely drag and drop, but not complex either

I personally go for lit[1] and sometimes typescript, and that's it. Typically use open-wc[2] to have a starting template under a minute.

Then I use any of the front-end libraries that add bells and whistles. Vaadin coming on top [3]

I'm a backender, I don't have time to, nor want to learn the specificities of a framework. And I don't want my users to have to pay the cost of many dependencies that I'm not using the full power of.

Add firebase or supabase with netlify for deployment, and I'm done.

[1]http://lit.dev/ [2]https://open-wc.org/ [3]https://vaadin.com/docs/latest/components

NextJS + MaterialUI + TypeScript + Vercel

I use these because I know them and I don't need to look for code or docs. And I feel the the tooling doesn't get in my way.

I feel that a UI components library is better suited for how I think, than a drag and drop config tool.

Passing props feels simpler than digging into menus to link that JSON to that calendar.

For those recommending Tailwind, it's huge if you're using it from the CDN (318K uncompressed).

Other tools (except for Tachyons, these are maybe out of scope for a home lab):

- Tachyons [0] is a small (16K-ish) utility class framework.

- DaisyUI [1] is a free and open source component lib for Tailwind.

- WindiCSS [2] is built on Tailwind with some additional features.

- UnoCSS [3], an interesting on-demand atomic CSS engine that supports Tailwind CSS, WindiCSS, Bootstrap, and Tachyons.

[0]: https://tachyons.io/

[1]: https://daisyui.com/

[2]: https://windicss.org/guide/

[3]: https://github.com/unocss/unocss

- Jinja templating as standalone or in Flask.

- Classless minimal CSS framework to make pages pretty without using css

- htmx

Try to avoid doing state management. If you have to do it, use a frontend framework at that point.

https://github.com/dbohdan/classless-css

sveltekit [1], orbit.js [2], JsonApiDotNet [3] and postgrest [4], additionally docker-compose, sometimes typeorm[5] + express. Good for prototyping and small home projects :-) Production readiness is questionable for the first 2 mentions...

:-)

[1]: https://kit.svelte.dev/

[2]: https://orbitjs.com/

[3]: https://www.jsonapi.net/

[4]: https://postgrest.org/en/stable/

[5]: https://typeorm.io/

I like https://tallstack.dev/ a lot.

But I think https://unpoly.com/ is nice also and works with any backend.

Tailwind for CSS is great too.

I am the developer of xlwings, so this is heavily biased. Anyhow, ever since I’ve added support for Google Sheets, I am building all internal tools with it. No HTML/JS/CSS required whatsoever and everybody knows how to interact with a spreadsheet UI. There are a few sample projects on GitHub, e.g., https://github.com/xlwings/xlwings-googlesheets-pandas-plots (they use FastAPI, but it’s trivial to adapt for Flask). On top, Google Sheets let you easily authorize the user on the backend, so you can give certain users read-only access to a database, as an example.

Really tired to find all kinds of modules for different function.

So even though I had bad experience with AngularJS, I still decided to learn Angular instead of React and Vue several years ago.

But if you only have some small projects, TypeScript is not better than JavaScript.

Simple? vanilla html, css and js.

I'm doing mosly machine learning/backend. For a PoC I needed a frontend, I choose Flutter web. The tooling works great and is unlikely to change everything week like in the JS world.

Dart is easy to learn and hasn't as many footguns as JS.

My last experiment was with bulma css and vanilla javascript (typescript) with web components for components that needed custom/complex interactions. Nice thing with this approach is that you can "just" render the web components with the backend's template engine as if those were your normal html tags. Because of typescript, a build step was required. For this I used esbuild (esbuild itself didn't do the type checking so I ran tsc with --noEmit and --watch next to it).

Didn't get that far with that project to see how it works when the code base scales. I would probably pick the same setup for my next greenfield project.

Back end dev here as well. Useful thread. Thanks.

It depends a bit. If you want a real "micro" framework so it is super fast loading, then that will narrow down your options (I looked at purecss which is really small) but then it is likely to lack the more powerful controls you get with something like bootstrap.

If you want more bells and whistles then bootstrap is fairly easy to understand, allows you to customise your js/css to only include what you are actually using but if you want the full scss experience to easily tweak parts of your design, it is all extra work to setup using gulp/webpack/visual studio code plugins or whatever.

You really want to use drag and drop as a dev?

I've been a front and back-end web dev for 20 years. For front-end I almost always use vanilla CSS, vanilla JavaScript, and vanilla HTML by way of the back-end SSR template system.

React.js is the gateway drug for you to dig into frontend development. I myself mastered it in 2 weeks as a backend engineer. There's no simple way, there's only the first step. Good luck.

Budibase is perfect for this use case. It is open source and super simple to build an app with. It's used at Apple, Google, Space X and other incredible orgs (power of open source)

Budibase.com

Not drag and drop but for a 100% python solution h2o wave is pretty cool. It has a focus on data-based dashboards but can be used to pretty easily create very good looking frontends for all sorts of applications. And you never have to leave python (whether that's a pro or a con is up for debate :))

https://wave.h2o.ai/docs/getting-started

I've been using Next.js for years to deploy static sites deployed to Github pages as well as experiments. It is quite simple and keeps my code organized.

Being no frontend dev myself, the rare times I have to do a webpage I go for jquery and bootstrap. May sound old-fashioned, and perhaps it is, but it works.

I reach for Vue + Vuetify (a Material Design UI component library) to get things going quickly. Vue is extremely easy to learn and can be incorporated with a script tag if you prefer. Vuetify faithfully implements almost the entire Material Web Components spec, so you have everything you need to build polished, functional web apps. It’s also got very nice documentation.

I am using Retool for that. Pretty happy. It is true drag and drop. Looks decent and there has been nothing I couldn't build with it.

May be unpopular, but: nextjs + react (+ bringing in typescript later if it starts feeling like types would be valuable).

1) React/jsx is legitimately nice for templating. Lets say I have a list of ten things I need to display; I know these things at build-time, its not dynamic like from an API or whatever. These ten things are reasonably complex; div+spans+borders+etc. React is all about components; it makes that easy, write once and copy-paste one line. There are ways to get similar behavior in plain HTML+CSS, but it tends to be leveraging web technologies that I'm not super familiar with (web components?).

2) React has an EXTREMELY good developer community. Everything you could possibly want, there's a component out there, and its an npm i away. In comparison, the more pure HTML/CSS world is more fragmented and less developed.

3) `next export`. When people think nextjs, they think SSR. Don't bother with it. Just `next export`. I leverage next for the local dev tooling, the runtime can take care of itself.

4) Or; I want server-side functionality. You can build backend-only API routes, in Next, and its actually awesome. Of course, you have to give up the static export, but its the first full stack JS "framework" where I've started thinking, this actually works & feels productive. Usually I leverage that for really simple stuff; server-side OAuth logins for hacky dashboards, things like that.

For deployment: netlify is nice, or I'll use digitalocean apps if its not a static export.

https://github.com/vladocar/femtoJS https://github.com/vladocar/Basic.css

Backend: Django / Celery - Front-end: TailwindCSS, daisyUI, HTMX, Hyperscript - Devops: VS Code dev containers than I can duplicate easily between projects to keep configuration.

I've written about just this subject as part of a series on my toolkit for building tiny apps. I use Material UI... React bindings for Material: https://link.medium.com/qPechTPYsrb

I used svelte for ( fabform . io )

Retool

https://retool.com/

Just use some simple CSS framework that you like/are used to plus maybe jquery if you need more than vanilla javascript.

This will get you a looong way and you don't even need npm for it.. just copy the minimized files into your source folder.

Check out:

https://docs.lowdefy.com/introduction

You need Node.js installed so that you have npx, but otherwise you just write your UI in yaml, because why the hell not?

Blade (Laravel), Tailwind and, unless I need complex state management, jQuery.

Check out shuffle.dev, they have generators and components for the most popular frameworks. A great way to learn is to create the same pages with different libraries and observe the similarities and differences.

Whatever JEE, Spring and ASP.NET support for SSR with components and vanilaJS.

Does AppSmith count? It's drag and drop and has themes. Easy to use with micro services. https://www.appsmith.com/

For real homebrew stuff that no one else is going to see, Flask with plain HTML. If someone else might actually see it, django and vue with one of the quickstart css things (Bootstrap, tailwind).

Related discussion from 2021 https://news.ycombinator.com/item?id=29311761

I usually just pull in fomantic ui (fork of semantic ui). It has all the components (and variants) I need, it’s easy to use and the components look much nicer than other ui frameworks.

Check out streamlit: https://streamlit.io/

All Python, no need for JavaScript, css, etc. Lots of example templates.

+1 for Svelte/SvelteKit. Svelte's DX feels like you are just using JS, CSS, and HTML - but you get all the new hottness of the other framework packages as you need it.

Check out Imba [https://imba.io/] It makes really simple to do what you're asking for.

Just use Bootstrap and axios library for making API requests to your REST API endpoints. You can find lots of free/paid templates and themes for Bootstrap.

Last time I did this, I bought a bootstrap template and just used django. Worked great, but you aren't gonna win friends on the internet talking about it.

Would Flutter be an option? You'd have to learn Dart but if you're familiar with JS its not hard to pick up. Run everywhere too, desktop, mobile, web.

Not sure that's what you're looking for, but my product www.jigdev.com definitely allows you to make simple UIs to interact with backend services

i recommend taking a boilerplate that is based on fast compiler (esbuild for example) and has tailwind set up. then add alpinejs for basic interactions. I think this stack has lowest barrier of entry for backend Devs, while having still a lot of room for growth. if you don't know tailwind, skip that part, it doesn't matter much, you can use whatever bootstrap-like library with great results.

https://github.com/Shopify/draggable

- Bootstrap

- Bootswatch

- Some custom scss to pop it up

- Some basic jQuery for everything dynamic

Simple yet super effective

For drag and drop try https://devdojo.com/tails

Wisej is just god-sent.

It has all I need, and lets me focus on business logic, rather than plumbing.

It is all one simple layer, no front-end/back-end.

In a similar position, I just went with 100% static Next.js, no over complicated server rendering, just basic React

I use Wordpress for drag and drop. More complex stuff Ruby on Rails with bootstrap.

JavaScript, HTML, CSS, PHP.

changes all the time. i like to learn new stuff so i always have a go at whatever shows up on HN.

if i had to pick, i'm a fan of nuxt. spinup is quick and easy and i'm a vuejs guy so its not that hard.

if you don't need a web application, pyqt can get you a desktop app up and running very quickly. it takes a little bit to understand the signal/slot design, but it's not too bad

I still use Adobe Dreamweaver for basic fronted development.

Vite + Vue.js 2 + Scss

I always use Vue. It's simple, flexible and powerful.

how about: html + css + js. The interactivity part can be done through preact + htm with JSX like syntax? Don’t need tools like webpack, vite, etc.

Took me a moment to realize that frontend here means HTML+js, not the HTTP server (that is the first server that handles user's request, therefore being the frontend to everything else).

the irony of this thread is beautiful.

I use Html + bootstrap + htmx + django

i just use bootstrap and jquery. no compilation or building. they have served me well for years

SwiftUI, HTMX

- Haskell (backend)

- SwiftUI (iOS/macOS)

- Rust (backend)

- VueJS

- Tailwind

- Netlify

Phoenix Framework

pnpm + Vite + Svelte + TypeScript + UnoCSS

Sveltekit

htmx or unpoly

dronahq

TailwindUI ?

AngularJS 1.8