The World Of Web Browsers Is In A Bad Way

There once was a man who invented a means for publishing scientific documents using hypertext. He made his first documents available from his NeXT cube, and a lot of the academics who saw them thought it was a great idea. They took the idea, expanded it, and added graphics, and pretty soon people who weren’t scientists wanted to use it too. It became the Next Big Thing, and technology companies new and old wanted a piece of the pie.

You all know the next chapter of this story. It’s the mid 1990s, and Microsoft, having been caught on the back foot after pursuing The Microsoft Network as a Compuserve and AOL competitor, did an about-turn and set out to conquer the Web. Their tool of choice was Microsoft Internet Explorer 3, which since it shipped with Windows 95 and every computer that mattered back then came with Windows 95, promptly entered a huge battle with Netscape’s Navigator browser. Web standards were in their infancy so the two browsers battled each other by manipulating the underlying technologies on which the Web relied. Microsoft used their “Embrace and extend” strategy to try to Redmondify everything, and Netscape got lost in the wilderness with Netscape 4, a browser on which nightmarish quirks were the norm. By the millennium it was Internet Explorer that had won the battle, and though some of the more proprietary Microsoft web technologies had fallen by the wayside, we entered the new decade in a relative monoculture. Continue reading “The World Of Web Browsers Is In A Bad Way”

The Gopher Revival Is Upon Us

A maxim for anyone writing a web page in the mid 1990s was that it was good practice to bring the whole thing (including graphics) in at around 30 kB in size. It was a time when the protocol still had some pretence of efficient information delivery, when information was self-published, before huge corporations brought everything under their umbrellas.

Recently, this idea of the small web has been experiencing something of a quiet comeback. [Serge Zaitsev]’s essay takes us back to a time before the Internet as we know it was born, and reminds us of a few protocols that have fallen by the wayside. Finger or Gopher, both things we remember from our student days, but neither of which was a match for the browser.

All is not lost though, because the Gemini protocol is a more modern take on minimalist Internet information sharing. It’s something like the web, but intentionally without the layer upon layer of extraneous stuff, and it’s been slowly gathering some steam. Every time we look at its software list it becomes more extensive, and we live in hope that it might catch on for use with internet-connected microcontroller-based computing. The essay is a reminder that the internet doesn’t have to be the web, and doesn’t have to be bloated either.

Virtual Yule Log Brings Old Tradition To The Web

Yule Log broadcasts are a bit of an American tradition, though similar content has also been broadcast around the world. They consist of a video of a log burning in a fireplace, ideally merrily so, and often feature Christmas carols or other holiday songs to help create a festive mood. [Joshua Gross] wanted to bring that tradition up to date, and thus built a Yule Log website with the help of some creative technologists.

What are Yule looking at?, as the project is known, features several web-based recreations of the Yule Log concept. They are charming little creations built with different techniques, from the AI-generated to those hewn from simple, pure HTML and CSS.  They range from cute 8-bit-esque tributes to burning firewood, to the ethereal and unrecognizable thought bubbles of an image-generating neural network. We’re pretty sure one of them is a oblique reference to an old Excel 97 Easter Egg, too.

It’s funny how much can be achieved within a modern browser window. Once upon a time, you were lucky to get a few GIFs and an obnoxious looping MIDI soundtrack.

A Collection Of Websites That Look Like Desktops

Web design has come a long way since those halcyon days of Web 1.0. There are plenty of rules about how to make a clean and efficient website, but sometimes it’s more fun to throw them out and just be creative instead. In that vein, [Simone] has curated a wonderful collection of websites that emulate the computer desktop experience online.

The collection’s website very much fits this theme. Upon visiting, an Award BIOS screen flashes up. From there, we get a Windows 95-like interface full of links to other sites that emulate a computer desktop layout. There’s even a 3D screensaver that pops up if you mouse away for too long.

There’s, which semi-accurately tells you information about your computer in a theme reminiscent of MacOS 9. Meanwhile, clicking on “It Is As if You Were Doing Work” will take you to a weird game that’s compelling in its replication of office banality. Nightwave Plaza offers exquisite vaporwave vibes, while others simply intend to faithfully recreate various OSes in a browser window.

It’s a fun collection of websites that go from the weirdly afamiliar to downright impressive recreations of former realities. It’s certainly fun to click around for a while and see what’s out there. We do love some good web ephemera around these parts!

Render HTML And CSS On An ESP32

As the available computing power from affordable microcontrollers continues to increase, there is an inevitable blurring of the line between them and the lower tier of application processors capable of running Linux-based operating systems. For the most part a microcontroller busies itself with behind-the-scenes tasks, but as so many projects here have demonstrated, they can be pretty capable when it comes to user-facing applications too. Now [Andy Green] has extended the possibilities with affordable silicon, by producing a proof-of-concept HTML + CSS renderer over h2 on ESP32 for libwebsockets. Surf the web on a microcontroller without settling for a text-only experience? Why not!

He freely admits that this is far from being a complete HTML rendering engine, in that while it parses and renders HTML and CSS with JPEG and PNG image support, it does so only with a subset of HTML and is not tolerant of any malformations. There is also no JS support, which is hardly surprising given the available resources.

Even with those limitations it remains an impressive piece of work, which we hope will one day be able to make some effort at displaying Hackaday on ESP32 devices such as the European conference badges. Definitely a project to watch!

Cable Modem Turned Spectrum Analyzer

Hopefully by now most of us know better than to rent a modem from an internet service provider. Buying your own and using it is almost always an easy way to save some money, but even then these pieces of equipment won’t last forever. If you’re sitting on an older cable modem and thinking about tossing it in the garbage, there might be a way to repurpose it before it goes to the great workbench in the sky. [kc9umr] has a way of turning these devices into capable spectrum analyzers.

The spectrum analyzer feature is a crucial component of cable modems to help take advantage of the wide piece of spectrum that is available to them on the cable lines. With some of them it’s possible to access this feature directly by pointing a browser at it, but apparently some of them have a patch from the cable companies to limit access. By finding one that hasn’t had this patch applied it’s possible to access the spectrum analyzer, and once [kc9umr] attached some adapters and an antenna to his cable modem he was able to demonstrate it to great effect.

While it’s somewhat down to luck as to whether or not any given modem will grant access to this feature, for the ones that do it seems like a powerful and cheap tool. It’s agnostic to platform, so any computer on the network can access it easily, and compared to an RTL-SDR it has a wider range. There are some limitations, but for the price it can’t be beat which will cost under $50 in parts unless you happen to need two inputs like this analyzer .

Thanks to [Ezra] for the tip!

SQLite On The Web: Absurd-sql

Love it or hate it, the capabilities of your modern web browser continuously grow in strange and wild ways. The ability for web apps to work offline requires a persistent local storage solution and for many, IndexedDB is the only choice as it works across most browsers and provides a database-like interface. However, as [James Long] found, IndexedDB is painfully slow on chrome and limited in querying ability. He set out to bring a tool he was familiar with, SQLite, and bring it to the web browser as absurd-sql.

Why absurd? Partially because most browsers (not chrome) implement IndexedDB on top of SQLite. So for many browsers, it is just SQLite on top of IndexedDB on top of SQLite. Luckily for [James] there already was a project known as sql.js that uses emscripten to compile the C-based SQLite into WebAssembly. However, sql.js uses an in-memory storage backing and all data is lost when refreshing the page. [James] tweaked SQLite’s method of reading and writing blocks. Instead of being memory backed, he added a layer to read and write blocks from IndexedDB. This means that only sections of the database need to be read in, bringing in huge performance gains.

a graph showing absurd-sql beating IndexDB on every benchmarkThat brings us to the other reason why it’s absurd. On chrome (as well as Firefox), absurd-sql beats IndexedDB on almost every benchmark. A query like SELECT SUM(*) FROM kv led to stunning results.

So what’s the downside? Other than a somewhat large WebAssembly file that needs to get downloaded (409KB) and cached, there really isn’t. Of course, it’s not all roses when it comes to web development. Native SQLite runs 2-3 times faster than absurd-sql, which demonstrates how slow IndexedDB really is.

There are other storage standards on the horizon for web browsers, but locking becomes an issue. SQLite expects synchronous reads and writes because it’s just simple C. IndexedDB and other storage solutions are asynchronous as the event loop of Javascript lends itself well to that model. Absurd-sql gets around that by creating a SharedArrayBuffer that is shared with a worker process. The atomics API is used to communicate with the buffer. In particular, atomics.wait() allows the worker to block main thread execution until the read or write has finished. From the perspective of SQLite, the operations are synchronous. IndexedDB provides transactions so multiple connections can happen (for example multiple tabs open). Multiple readonly transactions can occur in parallel but only one readwrite transaction can be in flight.

Why not pull up your browser and start playing around with it? You’re already doomed to learn WebAssembly anyway.