Show HN: CalDOM: An agnostic, reactive and minimalist JavaScript UI library (opens in new tab)

I honestly don’t know where this will lead. Probably all of this is just for nothing. The world has enough UI libraries already. Duh!.

I decided to make my own mini jQuery years ago because I wanted a lightweight library. Also, I wanted to stay close to the native DOM API & vanilla JavaScript. Looking back, it paid really well. Then React & Vue JS happened.

In my opinion, the reactive UI approach bought a huge productivity improvement from the perspective of the developer. Also, it enabled a lot of beginner developers to navigate the programming landscape more easily.

However, this shift also moved people away from the core stuff that’s happening under the hood. As a result, sometimes we have to struggle a lot to find solutions within the library’s limits, which are sometimes hilariously dead simple & performant to implement with native APIs.

CalDOM tries to solve this by being 100% interoperable with the native DOM. I hope this will be helpful for developers with similar requirements.

Introducing CalDOM, an agnostic, reactive & minimalist (3kb) JavaScript UI library with direct access to native DOM.

Instead of pulling you into a library-specific magical world, CalDOM let you fully access the DOM directly while keeping the reactivity. A 2-in-1 virtual-DOM & no-virtual-DOM approach if you will.

So you could take full advantage of native APIs & mix it with other libraries to gain superior performance & flexibility in the development process.

CalDOM does not require any dependency or tooling. It does not introduce any new syntax. Just pure JS.

This is the first time I’m publishing something like this. This was a simple jQuery alternative I made myself years ago & kept on improving it slowly. Worked really hard during the last few months to add reactivity and get it to this level.

Please check it out & let me know what you think, the good, bad & your suggestions to improve it.

Also, it's great if you could contribute to the project: https://github.com/dumijay/CalDom

The aesthetics of a programming language or framework are pretty important IMO, that's one of the reasons Python is my favorit language. This has a lot more punctuation, weird characters (underscore, seriously?), parenthesis and brackets than I ever willing to write or look at. In other words; it's very ugly.

Looks interesting! Kudos on the well documented source, benchmark and website.

Are Caldom instances itself always synced with the DOM? e.g. If I create a Caldom instance for all ‘button’ and add an event handler for ‘click’. Now another piece of JavaScript adds a button to the page, will the event handler also trigger for that button or just the buttons when I first instantiated Caldom?

That reminds me, few weeks ago, I read that Preact (a 3kb React alternative) could soon become faster than Vanilla JS.

Source: https://twitter.com/_developit/status/1412451442946981890

Hope this is helpful: the docs at https://caldom.org/docs/ have the table of contents cut off if the window is less than about 1800 px wide. Lots of screens are 1440 or 1280 or even 1024 px wide and won't be able to properly view the documentation. I think it would only take a few simple CSS changes to fix this.

Since I've started using Svelte (HTML-oriented, rather than JS-oriented), every other framework feels like such a mess.

I highly recommend React/Vue folks to check it out, it's literally 2x'd my productivity and completely obliterated the mental RAM i had to keep in order to "think in react"

Oh damn. I've been working on a project using very similar tricks for the passed ~3 years.

I'm assuming state is a proxy and you're using the single threaded nature of JS to make render functions dependent on accessed variables?

Am I the only one to write my own “framework” from scratch every time I start a new project?

These new “super lightweight frameworks” are only 3kb and as fast as vanilla js because they really don’t do much...

They always end up getting in the way though one way or another.

Writing a state and updating the DOM when the state changes really isn’t complicated at all.

People who don’t know how to do it need vanilla js template projects, not frameworks...

lately been using Mithril, small api surface but it's been good. I'm enjoying writing JS frontends, again! :) some things can be tricky but the community is helpful. I'm glad others are making tool-less frameworks. just plug it in the script tag and go to work. so props to the author for making something lightweight and straightforward!!

Interesting I'd still go for Lit (https://lit.dev/) though if you want something light weight and no/little build.

What does "agnostic" really mean here? Or, how is something like React not "agnostic"?

Why is "get the nth element from a list" spelled "eq"?

For the note: Sciter ( https://sciter.com ) implements CalDOM features out of the box. But better.

In Sciter DOM and vDOM are equally honored.

This CalDOM's (DOM + vDOM population):

    _("#output-1")
      .append(
        _("+h1").text("Hello World!")
      );

In Sciter is

    document.$("#output-1")
      .append(<h1>Hello World!</h1>)

And this reactive CalDOM:

    let app = _().react(
        {},
        {
            render: state =>
                _( "+h1", `Hello ${state.name}` ) //This is XSS safe
        }
    )

    _("#output-2", app );

    //Edit below line to update state
    app.state.name = "World Reactively ";

in Sciter is

    class App extends Element {
       name = "unknown";
       render() {
         return <body><h1>Hello { this.name }</h1></body>;
       }
    }

    document.body.patch(<App />);

    document.body.componentUpdate({name:"World Reactively "}); // will invoke render()