Ethereum Glamsterdam: What Developers Tested at Soldøgn

It’s 2 a.m., the room is dim, and someone just pushed a flood of test transactions that would make a mempool sweat. Laptops hum. Builders grumble. Clients log everything. This is Soldøgn — a long, messy sprint on Ethereum’s glamsterdam devnets.

By the end of the weekend, the network didn’t fall over. But a few things did bend in ways devs care about. That’s the point.

If you’ve been wondering what actually got tested, and why anyone outside that room should care, here’s the straight version.

Glamsterdam is the current cross-client devnet cycle where Ethereum client teams, builders, and protocol researchers push the next wave of changes until they break or prove boring. It sits before public testnets and mainnet — the place where bad ideas go to die and good ideas get sanded down.

Stress now is cheaper than regret later. Devnets let Ethereum find ugly edges in gas accounting, builder markets, and engine APIs before users ever feel them.

At Soldøgn, developers hammered glamsterdam with higher transaction loads, watched builder behavior under pressure, and iterated on gas semantics that ripple into wallets, rollups, and MEV infrastructure. The work feeds straight into the next spin of the cycle, DevNet-8, which is already queued up with a short list of non-negotiables.

What glamsterdam actually is

Think of glamsterdam as a rotating stage where every major Ethereum execution and consensus client shows up with near-final code, dials features on and off, and syncs on shared bugs. It’s not a fork name. It’s the live-fire dress rehearsal.

Where the current run started

Glamsterdam-devnet-6 went live on June 25, 2026, and ran with Gloas switched on from epoch 30 — a detail logged across client event streams and collated by the EthPandaOps team. Their event matrix, covering June 25 through July 9, gives a clean look at how clients observed and emitted the same state over time (EthPandaOps investigations (glamsterdam devnet SSE event support)).

Why devnets matter before testnets

Public testnets are great for app traffic and wallet UX. Devnets are where protocol people coordinate changes that affect how blocks get built, how gas is tallied, and how nodes talk to each other. If something slips here, everyone pays later: toolchains drift, builders fork their logic, and mainnet gets surprises.

Soldøgn: what actually got hammered

The Soldøgn sprint wasn’t about demos. It was about trying to break the plumbing.

Throughput drills

The headline result: glamsterdam-devnet-7 “held up well over the weekend with increased transaction loads,” according to the July 27 All-Core-Devs Testing notes. That’s the kind of boring you want to see after a sleepless weekend (All Core Devs - Testing (ACDT) #89 (ethereum‑magicians)).

Builder competitiveness under pressure

Less boring: builder issues. The same ACDT write-up flagged that Geth Builder and Nethermine weren’t consistently winning bids. That hints at competitiveness or integration gaps between builders, relays, and proposers when blocks get dense — the exact scenario MEV-aware infrastructure must handle cleanly (All Core Devs - Testing (ACDT) #89 (ethereum‑magicians)).

Edge-case failure hunts

Beyond raw throughput, teams poked at timing edges and accounting quirks. Several clients rolled in fixes over the weekend to close gaps exposed by the load tests, per the same notes (All Core Devs - Testing (ACDT) #89 (ethereum‑magicians)).

How the drills typically ran

1. Spin up patched client builds across diverse infra and confirm healthy peer views.
2. Crank transaction generators to target specific calldata and gas patterns.
3. Watch builder bid outcomes across relays while toggling load profiles.
4. Capture mismatches in event streams across clients and file diffs.
5. Patch, restart, repeat until the failure goes quiet twice in a row.

Gas accounting tweaks: naming, numbers, and ripple effects

One of the quieter but important threads in glamsterdam has been gas semantics. On July 27, client teams referenced a live pull request to rename the EIP-8037 term “regular gas” to “execution gas.” It sounds cosmetic, but the goal is clarity: separate what pays for EVM execution from other categories, so implementations and tooling talk the same language (All Core Devs - Testing (ACDT) #89 (ethereum‑magicians) — references PR #11998).

Why wording matters

Gas labels bleed into fee markets, wallet estimates, and how builders pick transactions. If two clients or libraries use slightly different names for the same accounting bucket, it’s a recipe for mispriced transactions or confusing RPC responses. Tightening the vocabulary early keeps explorers, SDKs, and relays aligned.

The repricing question

Alongside naming, “final repricing numbers” were flagged as a gating item for the next devnet. That points to calibration work — which operations should cost what, under load, with realistic blocks — before everyone locks code for the next lap (All Core Devs - Testing (ACDT) #89 (ethereum‑magicians)).

Builders, bids, and the relay reality

Builder hiccups during Soldøgn were a feature, not a bug. You want failures now, with eyes on logs and patch pipelines ready. The issue reported — Geth Builder and Nethermine not reliably winning bids — is a reminder that block production is an ecosystem dance, not a single binary.

What might cause a builder to miss

• Integration drift: a small API or payload expectation change can desync a builder from a relay or proposer.
• Timing sensitivity: higher load exposes latency paths that matter for bids.
• Accounting mismatches: if gas semantics diverge even slightly, a builder’s view of profitable bundles can skew against the network’s view.

The upside is simple: when multiple major builders misbehave under the same stress profile, it gives client teams and relay operators a shared, reproducible bug to crush. The Soldøgn cycle seems to have produced exactly that.

From DevNet-7 to DevNet-8: what’s left before the switch

Teams tentatively penciled an early August move from DevNet-7 to DevNet-8, with a short list of must-haves: land the final repricing values and roll in mandatory EIP-8070 engine API changes. No drama, just a clean migration target (All Core Devs - Testing (ACDT) #89 (ethereum‑magicians)).

Devnet Dates Focus areas Notable notes Source Glamsterdam-devnet-6 2026-06-25 → early July Baseline stability, feature flags (incl. Gloas from epoch 30) Cross-client event parity review; SSE event data captured EthPandaOps investigations Glamsterdam-devnet-7 July cycle, incl. Soldøgn weekend High-load transaction drills; builder competitiveness; gas semantics Held under load; builder bid issues observed; ongoing fixes ACDT #89 notes Glamsterdam-devnet-8 (planned) Target: early August Finalize repricing; integrate EIP-8070 engine API changes Gating items must land before spin-up ACDT #89 notes

Why EIP-8070 matters here

Engine API changes ripple into every execution client, relay, and builder path. Even small schema or field updates can break assumptions in middleware. Making EIP-8070 mandatory for DevNet-8 sets a line in the sand: update now, or you won’t participate.

Screenshot of the BAL benchmark dashboard used during Soldøgn, showing per-client BAL‑mode performance/leaderboard — the benchmark evidence teams used to calibrate the post‑Glamsterdam gas‑limit target. — Source: Ethereum Foundation Blog (Soldøgn Interop Recap)

Who should be paying attention — and what to do about it

Rollup teams

Gas semantics and repricing don’t just affect L1. They shape how L2s estimate fees, pick batch sizes, and handle worst-case execution spikes. Keep your gas models flexible until the DevNet-8 numbers stop moving.

Wallets and SDKs

Terminology changes like “execution gas” ripple into UX. If you label fees in-app, track the wording so you don’t confuse users or support teams. Also, monitor RPC responses for subtle field changes tied to the engine API work.

Builders and relays

If Geth Builder and Nethermine can slip under pressure, anyone can. Re-test integration with patched clients, rehearse relay failovers, and watch latency budgets when blocks fill faster than usual.

Infrastructure and node operators

Expect another cycle of binary churn as DevNet-8 lands. Pin versions with care, and keep a quick rollback path while you validate EIP-8070 compatibility in staging.

Risks & What Could Go Wrong

• Partial adoption of engine API updates creates fork-like behavior across builders and relays.
• Final gas repricing misses a corner case, causing wallet fee chaos or builder mispricing under stress.
• Client-specific fixes regress on other platforms or older hardware profiles.
• Monitoring and telemetry drift makes cross-client debugging slower in the next cycle.
• Terminology updates land in clients but not in wallets and explorers, confusing end users.

The biggest failure isn’t a crash in devnet. It’s a clean devnet that hides a mainnet problem. Assume nothing; re-test everything under fresh load patterns.

If you want a single place to track these iterations without living in meeting notes, Crypto Daily keeps an eye on devnets and the ACDT cadence and pulls in the right links when something actually moves (Crypto Daily).

Frequently Asked Questions

What is Soldøgn in this context?

Soldøgn here refers to a concentrated developer sprint tied into the glamsterdam devnet cycle. It’s not a public testnet event. Think long working sessions where client teams, builders, and researchers coordinate stress tests and patches.

Why did glamsterdam-devnet-7 matter?

It was the first cycle where developers publicly noted the network holding under heavier loads while also exposing builder bid issues worth fixing before the next spin. That combination — stability plus actionable failures — is productive (ACDT #89).

What’s the deal with “execution gas” vs “regular gas”?

Teams are cleaning up terminology in EIP-8037, shifting from “regular gas” to “execution gas” to make it clearer which costs refer to EVM execution. It reduces ambiguity across clients, SDKs, and explorers as changes move forward (ACDT #89 — PR #11998).

What is Gloas and why is it mentioned?

Gloas was active from epoch 30 on glamsterdam-devnet-6, according to EthPandaOps’ event analysis. It’s cited to note which features were on during earlier testing; the specifics matter mainly for client parity and logging (EthPandaOps).

When is DevNet-8 expected?

Planning notes point to an early August target, with final gas repricing numbers and mandatory EIP-8070 engine API changes as the key gates before spin-up (ACDT #89).

Do these devnet results affect users today?

Not directly. Devnets are pre-testnet. But the fixes and naming choices travel quickly into public testnets, then mainnet. Wallets, rollups, and builders that track devnet changes will adapt sooner and avoid rough edges later.

How can a project team replicate Soldøgn-style tests?

Use the same pattern: align on client versions, script varied load profiles, record cross-client events, track builder outcomes across relays, and iterate until your failure cases go quiet. Then do it again after each API or repricing change.

Disclaimer: This article is provided for informational purposes only. It is not offered or intended to be used as legal, tax, investment, financial, or other advice.