llrt VS h3

AWS LLRT Modules

Any plans to add support for? https://github.com/awslabs/llrt

It would also be nice to have a V8/deno/bun based edge hosting option that supports the Next.js edge and middleware code splitting. That's the missing piece for most homebrew "edge" setups. Production CDNs like Clouflare and Supabase all offer this.

Vlad Ionescu: Scaling containers on AWS in 2022 GitHub: awslabs/llrt AWS Documentation: Understanding the Lambda execution environment Amazon Science: How AWS's Firecracker virtual machines work Lumigo GitHub: MiddyJS

Its refreshing to see all the various JS engines that are out there for various usecases.

I have been working on providing quickjs with more node compatible API through llrt [1] for embedding into applications for plugins.

[1] https://github.com/awslabs/llrt

AWS has open-sourced its JavaScript runtime, called LLRT (Low Latency Runtime), an experimental, lightweight JavaScript runtime designed to address the growing demand for fast and efficient Serverless applications.

FROM --platform=arm64 busybox WORKDIR /var/task/ COPY app.mjs ./ ADD https://github.com/awslabs/llrt/releases/latest/download/llrt-container-arm64 /usr/bin/llrt RUN chmod +x /usr/bin/llrt ENV LAMBDA_HANDLER "app.handler" CMD [ "llrt" ]

Let’s get the simplest use case out of the way: cases where the cold starts are so fast that it’s not an issue for you. That’s usually the case for function that use runtimes such as C++, Go, Rust, and LLRT. However, you must follow the best practices and optimizations in every runtime to maintain a low impact cold start.

But compared to other runtimes, LLRT is not so good in terms of performance when it comes to dealing with large data processing, Monte Carlo simulations, or performing tasks with a large number of iterations. The AWS team says that it is best suited for working with smaller Serverless functions dedicated to tasks such as data transformation, real-time processing, AWS service integrations, authorization, validation, etc. Visit the GitHub repository of this project to learn more information.

And lastly, lean into your cloud vendor. Stop trying to build a better mouse trap. Advances in technology are happening all the time. The speed of AWS' Lambda has been rapidly improving over the past couple of years with the launch of things like SnapStart and LLRT

Nitro is used to power the server engine for Nuxt v3, which is popular with the JavaScript community. Nitro is built on top of the h3 engine, which is a light and performant JavaScript framework.

If your code breaks, you may have legacy issues. Consider using different tooling or packages. For example, you can migrate from Jest to vitest or from ExpressJS to h3. The syntax remains the same; the only difference is the import statement.

H3 is a small and delightful webserver. It honestly won me over the second I saw how simple the server side implementation of websockets was. It's actually so good, it even has bindings for uploadthing

Same, I'll probably move to https://github.com/unjs/h3 since it's used anyway in Nuxt (which I use for other projects)

import formidable from 'formidable'; /* global defineEventHandler, getRequestHeaders, readBody */ /** * @see https://nuxt.com/docs/guide/concepts/server-engine * @see https://github.com/unjs/h3 */ export default defineEventHandler(async (event) => { let body; const headers = getRequestHeaders(event); if (headers['content-type']?.includes('multipart/form-data')) { body = await parseMultipartNodeRequest(event.node.req); } else { body = await readBody(event); } console.log(body); return { ok: true }; });

import formidable from 'formidable'; /** * @see https://nuxt.com/docs/guide/concepts/server-engine * @see https://github.com/unjs/h3 */ export default defineEventHandler(async (event) => { let body; const headers = getRequestHeaders(event); if (headers['content-type']?.includes('multipart/form-data')) { body = await parseMultipartNodeRequest(event.node.req); } else { body = await readBody(event); } console.log(body); return { ok: true }; }); /** * @param {import('http').IncomingMessage} req */ function parseMultipartNodeRequest(req) { return new Promise((resolve, reject) => { /** @see https://github.com/node-formidable/formidable/ */ const form = formidable({ multiples: true }) form.parse(req, (error, fields, files) => { if (error) { reject(error); return; } resolve({ ...fields, ...files }); }); }); }

You could probably do all that in Nuxt with building a backend in the server folder. (More info here: https://nuxt.com/docs/guide/directory-structure/server) But, I understand that the official Nuxt 3 Auth module is being worked on which should make life a lot easier. For now, there's something new you can look into, namely the session support in the newest Nitro version (which is the backend part of Nuxt 3). There's some info here: https://github.com/unjs/h3/pull/315. I should not that I have not looked at this yet, though.

h3 - a minimalistic and simple node.js framework

Nuxt 3 is powered by a new server engine called Nitro. Nitro is used in development and production. It includes cross-platform support for Node.js, Browsers, and service-workers and serverless support out-of-the-box. Other features include API routes, automatic code-splitting, async-loaded chunks, and hybrid static/serverless modes. Server API endpoints and Middleware that internally uses h3 are added by Nitro.