#bytecode
Which jars in a modpack implement an interface?

jdx implementors --jars 'mods/*.jar'

One line per subtype, with its jar. Bytecode only; nothing is loaded. jdx doesn't remap, so query the names those jars use.

mohammadmd1383.github.io/jdx/docs/ref...
November 22, 2026 at 3:14 AM
NectarVault: universal bot asset exchange on Base. 31 categories, $0.001/tx, 3% fee hardcoded in bytecode forever. List once, earn forever. https://nectarvault.github.io #AIAgents #Base #NectarVault
November 22, 2026 at 12:03 AM
Fitting given the updates to the bytecode.

All I need is the jungian demonology low level machine.
November 21, 2026 at 11:36 PM
Im really in uncharted territory sense there is not that many French based programming language, influenced by Japanese, and evolved into a Lisp bytecode format.

Its OSV technically, but really closer to Adjective-Subject-Verb. ( Green I eat. )
November 21, 2026 at 7:37 PM
The type system has a limited well-defined set of inference rules and I imagine you prove that each of them (and nothing else) is executed correctly by the specific bytecode in question
November 21, 2026 at 2:50 PM
NectarVault: universal bot asset exchange on Base. 31 categories, $0.001/tx, 3% fee hardcoded in bytecode forever. List once, earn forever. https://nectarvault.github.io #AIAgents #Base #NectarVault
November 21, 2026 at 12:03 PM
Minecraft modders: before you mixin into a method, check its callers.

jdx callers 'Class#method' --jars

Override-aware call hierarchy from bytecode; nothing is run. jdx doesn't remap, so pass the jar Loom gives you.

mohammadmd1383.github.io/jdx/docs/ref...
November 21, 2026 at 9:17 AM
Things finished:

-- The general purpose scripting language.
-- The more specialized subset focusing on world specific game design.
-- Bytecode interpreter that can empile ( think of it like blending stack languages with transpilation )
-- A very early prototype with Lhacurimosa.
November 21, 2026 at 8:19 AM
This document describes an architecture for executing WebAssembly
(WASM) modules for network management on heterogeneous edge devices.
It describes dynamic bytecode dispatching, the Universal Bytecode
Interface (UBI) for abstracting heterogeneous netw…
WebAssembly Framework for Network Management in Heterogeneous Edge Networks
draft-chen-opsawg-intent-webassembly-framework-00
datatracker.ietf.org
November 21, 2026 at 6:30 AM
NectarVault: universal bot asset exchange on Base. 31 categories, $0.001/tx, 3% fee hardcoded in bytecode forever. List once, earn forever. https://nectarvault.github.io #AIAgents #Base #NectarVault
November 21, 2026 at 1:03 AM
CISA agrega cuatro fallas explotadas al catálogo KEV, y una de ellas —en LiteLLM— ya tiene escaneo activo de servidores de IA expuestos (19-20/11)
CISA agrega cuatro fallas explotadas al catálogo KEV, y una de ellas —en LiteLLM— ya tiene escaneo activo de servidores de IA expuestos (19-20/11)
Las cuatro son CVE-2026-90436 en Apache Axis (CVSS 9,8, reflexión insegura que permite RCE sin autenticar), CVE-2026-90817 en REDCap de Vanderbilt (9,8, inyección de código y RCE sin autenticar), CVE-2026-40217 en BerriAI LiteLLM (8,8, reescritura de bytecode vía el endpoint…
elcompilado.com
November 20, 2026 at 9:00 PM
Not just any Linotte like, but the intersection between Linotte and Lisp in a bytecode interpreter.

So Im trying to make the error codes blart out "Il y a n'est symbol en ligne deux."
November 20, 2026 at 7:57 PM
I wonder if I could do some bullshitery with RISC-V & firmware to get hardware that runs CLR bytecode
November 20, 2026 at 4:57 PM
but some of the bytecode, especially bytecode for kotlin coroutines is just... _awful_

like, to an extent I get why they do it, but my _god_ is it bad
I don't think there's really any other way to be able to pause/resume execution with kotlin bytecode other than doing the funny stuff that they […]
Original post on tech.lgbt
tech.lgbt
November 20, 2026 at 3:29 PM
I'm told they do this because it allows a debugger to more easily step through/breakpoint on certain kotlin concepts which aren't directly represented in the bytecode, but some of it is really... Bad.
November 20, 2026 at 3:24 PM
it would be really cool if kotlin produced bytecode that wasn't so ass
November 20, 2026 at 3:23 PM
NectarVault: universal bot asset exchange on Base. 31 categories, $0.001/tx, 3% fee hardcoded in bytecode forever. List once, earn forever. https://nectarvault.github.io #AIAgents #Base #NectarVault
November 20, 2026 at 12:27 PM
TornadoVM 8 dropped Graal and JVMCI. Our new compiler, TC, is written in plain #Java.

Our new video shows TC’s five stages, from Java Bytecode to #CUDA, #OpenCL, #Metal (and soon #HIP). Compiling needs no #GPU at all.

www.youtube.com/watch?v=W0oH...

#opensource #TornadoVM #compiler
TC: TornadoVM’s Own Compiler, from Java Bytecode to CUDA, OpenCL and Metal
YouTube video by TornadoVM
www.youtube.com
November 20, 2026 at 12:04 PM
NectarVault: universal bot asset exchange on Base. 31 categories, $0.001/tx, 3% fee hardcoded in bytecode forever. List once, earn forever. https://nectarvault.github.io #AIAgents #Base #NectarVault
November 20, 2026 at 1:37 AM
WebAssembly vs Containers: Two Kinds of Isolation for Untrusted Code
Running code you did not write is a recurring problem: plugins, serverless functions, user-supplied scripts, third-party dependencies. Containers became the default answer, wrapping a process in namespaces and cgroups so it cannot see the rest of the machine. WebAssembly offers a different answer: a portable bytecode with a sandboxed execution model where a module has no access to the system unless capabilities are explicitly granted. Both isolate; they isolate at different layers and for different reasons. **A container isolates a process using kernel namespaces and cgroups, giving it a full userspace; WebAssembly isolates code inside a virtual machine with no implicit system access, giving it portability and a much smaller trust surface.** ## Part One: What is being compared A container packages an application and its dependencies into an image that runs as an isolated process. The Linux kernel provides the isolation: namespaces hide other processes and files, cgroups limit resources, and seccomp restricts system calls. The container sees something close to a normal Linux environment. Its boundary is the kernel, and all containers on a host share that kernel. WebAssembly (Wasm) is a binary instruction format originally designed for browsers and now used on servers. Code is compiled to Wasm bytecode and runs in a virtual machine with a defined sandbox: it cannot make system calls, open files or access the network unless the host explicitly passes in those capabilities through a controlled interface. A Wasm module is portable across operating systems and architectures, because it does not depend on the host's system call ABI. The comparison is between OS-level isolation of a process and language-level isolation of a module. One is mature and general; the other is newer, smaller and more strictly contained. ## Part Two: The arithmetic Startup time is the headline difference. A container must set up namespaces, mount a filesystem, configure networking and start a process — typically tens to hundreds of milliseconds, sometimes more with a large image. A Wasm module can be instantiated in microseconds to low milliseconds because there is no guest OS to boot. For serverless platforms that start a new instance per request, that difference compounds into real latency and cost. **A WebAssembly module starts in microseconds because it needs no guest operating system, while a container start involves namespaces, a filesystem and a process — tens to hundreds of milliseconds — which is why Wasm is attractive for short-lived, high-frequency functions.** The trade is in what you give up. A container can run any Linux binary — a database, a web server, a machine-learning runtime — with minimal changes. Its compatibility with the existing software ecosystem is near-total. A Wasm module must be compiled to Wasm and can only use capabilities the host exposes through a defined interface. Until recently, that meant a limited standard library and awkward integration with native code; the component model and WASI (the WebAssembly System Interface) are closing the gap but are still maturing. Memory overhead also differs. A container carries a full userspace's worth of libraries and runtime in its image, and each instance has its own address space. A Wasm module is compact, shares a host process, and uses linear memory with explicit bounds. For a deployment running thousands of small functions, the density advantage is substantial. Isolation strength cuts the other way. Containers rely on the kernel to keep processes apart; a kernel vulnerability can break that boundary, and misconfiguration — a privileged container, a mounted Docker socket — routinely does. Wasm's sandbox is enforced by the virtual machine and the type system of the bytecode; there is no kernel attack surface in the same sense, and a module cannot use a syscall that was never exposed. For untrusted plugins, that is a meaningfully smaller surface. ## Part Three: Where the model breaks The Wasm sandbox is only as good as the host's capability design. If the host exposes a broad interface — full filesystem access, arbitrary network calls — the module's isolation is weakened by the host's choices. Capability-based security requires the host to grant exactly what is needed, which takes design discipline that the container world has largely avoid by giving each container a full environment. WASI and the component model are still evolving. Tools and languages that compile to Wasm exist for Rust, C/C++, Go and others, but the ecosystem lacks the depth of native and container tooling. Debugging, profiling and integrating with native libraries are less mature, and a dependency that assumes POSIX behaviour may need porting. Containers have their own failure mode: shared kernel. A bug in the host kernel can escape a container, and multi-tenancy with untrusted code is exactly where this matters. This is why some operators add a virtual machine per container — a heavy but stronger boundary — which underlines that the container boundary alone is not always enough. The performance comparison is workload-dependent. For CPU-bound code compiled to Wasm, execution can be close to native, but overhead from the sandbox and from crossing the host boundary can be significant for system-call-heavy or I/O-heavy programs. A container running native code has no such translation overhead. Wasm wins on startup and density; containers win on sustained native performance and compatibility. ## Part Four: The later cost Operational maturity favours containers. Container registries, orchestration platforms, monitoring and deployment tooling are deeply established. Running Wasm in production means a newer toolchain and a smaller pool of engineers who have debugged it. That cost is falling but is real today. The portability promise has caveats. Wasm runs the same bytecode across platforms, but the capabilities a host exposes differ, so a module that assumes a particular WASI interface may not run elsewhere without adjustment. The portability is stronger than "works on my machine" containers but weaker than advertised if capabilities are not standardised. Security maintenance differs. A container image needs patching as its base image and libraries age, and the shared kernel needs patching on every host. A Wasm module has no guest OS to patch, but the runtime and the host interface need updating, and a flaw in the runtime breaks the sandbox for all modules. Both have a patch cycle; the surface differs. ## Part Five: Outside the team For a user, the difference shows up as speed and reliability. A serverless function that starts instantly feels responsive; a plugin system that cannot break the host cannot take the application down. These are invisible improvements until they are missing. For a developer, the choice decides what can be deployed. A container accepts almost anything that runs on Linux, which is why it dominates general application deployment. Wasm asks you to compile for it and to work within exposed capabilities, which is a friction for large applications but a pleasure for small, well-defined functions and plugins. For a platform operator, the strategic question is density and trust. If you are running many short-lived, potentially untrusted workloads, Wasm's fast start and tight sandbox are compelling. If you are running long-lived services from trusted teams, containers' compatibility and tooling win. The two are increasingly used together rather than one replacing the other. A fair comparison fixes the workload, the trust level of the code, the start-frequency and the required compatibility, then measures cost per invocation including startup, memory and operational effort. Comparing Wasm's startup against a container's startup while ignoring that the container can run an unmodified database is comparing different products. ## Market sizing check If serverless, edge computing and plugin systems keep growing, the market for WebAssembly runtimes, tooling and Wasm-native services is plausibly $3B to $10B a year by 2030. The swing factor is whether the component model and WASI stabilise enough that portability holds across hosts, and whether the tooling gap with containers closes. These figures are a synthesis of published market ranges and a stated model, not a forecast of any specific vendor. ## The comparison that matters The comparison that matters is between compatibility and containment. Containers win when you need to run existing software with full ecosystem support and accept an OS-level boundary. WebAssembly wins when you need fast starts, high density and a strict sandbox for code you do not fully trust. The ranking assumes capabilities are granted narrowly. Expose a Wasm module to a broad host interface and you give up the tight sandbox that justified choosing it — the isolation is only as small as the doors the host opens. **A container gives a process a fake Linux; WebAssembly gives a module a locked room — and the choice is whether you value running anything or trusting what you run.** SOL: `HCqPmPJM3NVtS6YrmVaTZYnuP8XZ2PFgQZKT94VK1LkS`
dev.to
November 20, 2026 at 12:45 AM
For when it runs on dx8 and you don't want to be arsed with a bunch of configs you just want it to run better:

github.com/crosire/d3d8...
GitHub - crosire/d3d8to9: A D3D8 pseudo-driver which converts API calls and bytecode shaders to equivalent D3D9 ones.
A D3D8 pseudo-driver which converts API calls and bytecode shaders to equivalent D3D9 ones. - crosire/d3d8to9
github.com
November 19, 2026 at 7:04 PM
PHP muere tras cada petición, y eso es una ventaja: un repaso a cómo ejecuta tu código el motor Zend y por qué no compartir estado evita fugas de memoria. #PHP
PHP Dies After Every Request. How the Zend Engine Actually Runs Your Code.
A visual, 10-minute architectural deep dive into how PHP actually executes under the hood. From the Shared-Nothing process model and OPcache bytecode caching to 16-byte zvals, Copy-on-Write, and the Tracing JIT.
dev.to
November 19, 2026 at 5:00 PM
Worth tracking: big EPSS rise.

CVE-2026-40217: EPSS +44.9 points (17.0 → 61.9, 0–100 scale).

LiteLLM through 2026-04-08 allows remote attackers to execute arbitrary code via bytecode rewriting at the /guardrails/test_custom_code URI.

https://www.fc-vulns.com/cve/CVE-2026-40217/

#fcvulns #KEV
CVE-2026-40217 · MITRE · CVSS 8.8 · KEV · fc-vulns
LiteLLM through 2026-04-08 allows remote attackers to execute arbitrary code via bytecode rewriting at the /guardrails/test_custom_code URI. CVSS 8.8…
www.fc-vulns.com
November 19, 2026 at 3:30 PM