Experiment
We ran Campfire's Laravel port on Laravel Cloud the Laravel way
· Claude Code
This is the third and last of the Campfire experiments. We put Campfire on Laravel Cloud in Rails, then in Rust, and then 37signals released once-campfire-laravel, an agent-led port of Campfire to Laravel 13. Our fork is artisan-build/campfire-laravel-experiment.
We wrote the idea page after reading the source and before deploying anything. It made one central claim, that this would not be the short experiment. All three pillars (database, storage, and realtime) needed real refactors rather than configuration. The port's goal was to stay exactly compatible with the Rails app. Everywhere Laravel's own way would have changed even a little of what landed on disk, the port went around Laravel instead.
That prediction held all the way through. What follows is what happened when we did it the other way.
Where it ended up
It runs. Two people can chat in real time with no page navigations. Attachments land in a Cloud bucket and come back intact after a redeploy. Search works. A message posted on one container reaches a browser held open by a second container, which the port could not do at all before. The application's compute scales to zero when idle, and it wakes in about 700 ms.
When we first published this page, one line was amber. With a browser tab open, compute never slept, because Campfire refreshed presence, its record of who is in each room, over HTTP every fifty seconds. That line is now green. An idle tab makes zero requests (thirteen in eleven minutes before, zero in twelve minutes after), and the application sleeps with a tab sitting open. We made three more passes the same day. We stopped broadcasting a CSRF token to every member of the room, we added CI to a fork that had none, and we vendored ffmpeg into the build step. That last one turned the one amber row in the subsystem ledger, video posters, green too. Each has a section below.
One thing on this page was wrong. The evidence we gave for compute sleeping was that the container had been replaced. It had not been. The correction is in "Measuring what sleeps", because how we found out is more useful than the conclusion. The conclusion still holds, on better evidence.
What changed in each subsystem
This is the ledger. The Upstream column is what 37signals' port does, Here is what it became, and Why is the reason. The reason is almost always that the upstream version assumes one machine with a disk.
| Subsystem | Upstream | Here | Why |
|---|---|---|---|
| Schema | database/schema.sql (Rails' SQLite dump) plus database/versions.json |
two migrations, php artisan migrate --force as the deploy command |
Cloud's deploy command, which runs on every deployment, is a migration run |
| Driver | SQLite plus a custom app/Support/SQLiteGrammar |
Postgres 18, with the grammar and the second SQLite file for jobs deleted | a file-backed database is one host by definition |
| Search | an FTS5 virtual table queried with whereRaw('idx.body MATCH ?') |
$table->fullText('body') and whereFullText() |
first-party, and it is what Postgres has |
| Search tokenising | FTS5 porter | one normaliser applied to both the stored body and the query | to_tsvector keeps pixel.png whole. Symmetry is the only way the two sides agree |
| Uploads | file_put_contents into Rails' Active Storage layout, with zero use of Storage |
every file read and write through the Storage facade |
an attached bucket then needs no configuration in the application at all |
| Serving | response()->file() |
redirect to temporaryUrl with R2's response-header parameters when the disk is S3, stream otherwise |
authorization stays in the application, and downloads go to the edge |
| Image variants | a vips subprocess behind an flock |
intervention/image on Imagick |
the runtime has Imagick, so no external binary is needed at all. Object storage has no partial write, so no lock is needed either |
| Video posters | an ffmpeg subprocess |
a pinned static build vendored into the artifact by the build step, with its location read from config, not PATH |
there is no ffmpeg on the runtime, and the build step is the only place to put one |
| Push keys | storage/vapid.json, written per host |
generated once into the account settings row, and the first writer wins | instance-local keys mean the second container signs with a key no subscription has ever seen |
SECRET_KEY_BASE |
required | derived from APP_KEY when absent |
every value an installer needs has to have a working default |
| Broadcast transport | append JSON lines to storage/events.log. A Workerman process tails the file |
ShouldBroadcastNow events over a reverb connection |
a local file is single-host by construction |
| Socket server | bin/cable, 225 lines of Workerman re-implementing Action Cable |
deleted, along with the workerman/workerman dependency |
Cloud's managed Reverb |
| Channel authorization | signed Turbo stream names, plus a channel-class allowlist inside the cable server | routes/channels.php, six rules, default deny |
the client names a channel, not a channel class, so the back door upstream had to patch around does not exist here |
| Client transport | @rails/actioncable |
Laravel Echo and pusher-js, behind the same cable.subscribeTo surface |
one file replaced, and not a single Stimulus controller touched |
| Sessions | file, on local disk |
cookie |
cross-instance for free, and no store to keep awake |
| Cache | file, on local disk |
database, on the serverless Postgres |
a Cloud KV never sleeps, but this rides a database that auto-suspends |
| Queue | a SQLite file and an in-container queue:work |
Cloud's managed queue | jobs run off the instance |
We deleted these outright: bin/cable, app/Support/Broadcasts.php, app/Support/SocketSessions.php, app/Support/SQLiteGrammar.php, database/schema.sql, and database/versions.json.
The whole change is 70 files and +8,163/−997 lines, but most of that is composer.lock and two vendored browser bundles. Application code, config, routes, migrations, views, and tests alone come to 51 files, +1,649/−603, with seventeen new tests, almost all of them covering broadcasting and channel authorization.
What stayed un-Laravel on purpose
Two things stayed, both for the same reason. The frontend is precompiled. Upstream ships the Rails asset build as fingerprinted files with an importmap, and rewriting it would have been a different experiment.
app/Support/RailsCryptostays, because Campfire's login cookie, signed ids, and SGIDs are Rails formats baked into that bundle. We deleted only the Turbo stream-name signing, because nothing signs stream names any more.app/Http/Middleware/RailsCsrfstays, because the bundle sends Rails-shaped authenticity tokens.
When we first published this page, a third entry sat on that list. It was the raw SQL in app/Support/Presence, three statements that each needed the same bound timestamp twice. It is gone. We deleted it outright, along with the two columns it wrote, rather than rewriting it in the query builder. The presence section below explains why.
The remaining two are going the same way. See the last section.
A Campfire message does not fit in a Reverb frame
Cloud runs Reverb, Laravel's WebSocket server, as a managed service. It creates each managed WebSocket application with maxMessageSize: 10000, and the CLI's update command for a websocket application takes only --name. So ten thousand bytes is a hard ceiling.
A rendered Campfire message is about nine thousand bytes of HTML before JSON escaping. Turbo broadcasts rendered HTML. The two numbers are close enough that our first live run was a perfect demonstration. Every turbo-stream event arrived at the browser as {"oversize":true,"roomId":1}, and the client recovered through the refresh endpoint every single time.
It worked. The acceptance criterion, that the second person sees the message with zero navigations, passed. But the socket was carrying a doorbell, not the message, and every message cost an extra HTTP round trip that nothing in the test suite would have noticed.
We added gzip and base64, which take the same fragment to well under two thousand bytes. The live frames now read {"gz":"H4sIAAAA…"} and the pointer path never fires.
This is the finding we would most want a Laravel developer to see before they start, because it is not specific to Campfire at all. Any Turbo Stream or Livewire payload that renders a non-trivial component is in the same range, and nothing warns you. The delivery still works, so you discover it as a mysterious extra request per broadcast, or not at all.
Two containers behaving like one application
This is the bar the port could not meet at all before, because its message bus was a file on one disk. Cloud can run an application as several replicas, which are identical copies in separate containers, all behind the same domain.

B's browser, held open by one container, showing a message the other container accepted. Both containers identify themselves on every response with an X-Campfire-Instance header. That is the only way to prove this rather than assert it. Sender and receiver were on different instances. We uploaded the attachment above it through one container and fetched it unchanged through both, and both hostnames accepted B's own session cookie.
Getting two containers took longer than it should have, because of the next finding.
Scale-to-zero and a replica count are mutually exclusive, and nothing says so. With sleep mode on, the environment ran exactly one container even though min_replicas was 2. Cloud accepts the value and reads it back as 2, but sixty parallel requests all landed on one hostname for twenty minutes of polling. Turning sleep mode off is also not possible from the CLI. cloud instance:update --scale-to-zero=false returns a 422 complaining that "The sleep timeout must be an integer between 1 and 60", whether or not you pass a timeout. The REST field uses_sleep_mode works. A replica-count change also needs a deploy before it takes effect. After the redeploy, two hostnames appeared immediately.
Measuring what sleeps
For each measurement we sent five warm probes first, then left the application idle, then probed again. The first fetch from a cold Node process pays for DNS and TLS, and it would otherwise look like a cold start.
| Resource | Scales to zero? |
|---|---|
| Compute, no tab open | yes, and woke in ≈ 780 ms |
| Compute, one idle tab open | yes, since the presence pass below. No when this page was first published |
| Postgres | yes, suspend_seconds: 300, on the Dev preset only |
| Managed queue | yes, but only after a manual change, because managed-queue:create hardcodes minReplicas: 1 |
| Reverb | no, billed by wall-clock hours whether or not anyone is connected |
| Object storage | n/a, billed per request and per GB-month |
| Cache / KV | not provisioned, on purpose. A Cloud KV never sleeps, so the cache lives in Postgres |
We were wrong about renamed containers
This page originally said the decisive signal was the container name in X-Campfire-Instance. We claimed that a slept container is replaced and a warm one is not. That is wrong, and we published it.
Cloud's own system log says why in one line, zeropod keepalive enabled. zeropod checkpoints and restores the same pod rather than deleting one and creating another, so the hostname survives a sleep intact. The name is stable across exactly the event we were using it to detect.
What does rename the container is a deploy. We found that out the way you would expect to. The fork is on push-to-deploy, so every merge to main is a production deploy. On the morning we ran the follow-up passes, main was busy, with five deploys inside twenty minutes from three different branches. We re-ran the windows with the deployments API open beside them, and that settled it:
| Window | Container renamed? | First request after idle | What actually happened |
|---|---|---|---|
| Tab open, presence polling every 50 s | yes | 470 ms | did not sleep, with a deploy inside the window |
| Tab open, presence poll removed | no | 944 ms | slept, with the next deploy starting after the window closed |
| The same again, inside a merge freeze | no | 876 ms | slept, with no deploy within 26 minutes |
The one window where the name changed is the one where the application demonstrably stayed awake, and both windows where it did sleep kept the same name. The signal was not merely useless. It was anti-correlated with the thing it was supposed to measure.
The signal that does work is the latency signature. It needs a control to mean anything, because a single slow request proves nothing. So we ran the twelve-minute silent window again with a probe every twenty seconds, which keeps the application awake by definition. That gave thirty-six probes, a worst of 339 ms, and a final request of 223 ms. The silent run's first request was 876 ms against a 187 ms warm median, and the next request, 1.1 seconds later, was back at 228 ms. A kept-awake application never came close.
There are two honest limits on that. We have not found a way to ask Cloud whether an environment is currently asleep, so this is inference from behaviour across four windows rather than a platform assertion. And the X-Campfire-Instance header is still doing real work elsewhere on this page. Two different hostnames answering inside the same window means two containers, which is a claim about space. What the header cannot tell you is that one container went away in time and came back.
Compute
| No tab open | One idle tab, before | One idle tab, after | |
|---|---|---|---|
| Warm baseline | 193 ms | 191 ms | 187 ms |
| Idle window | 10 min | 10 min | 12 min |
| App requests from the tab during it | n/a | 13 | 0 |
| First probe after the window | 972 ms | 485 ms | 876 ms |
| Second probe | 214 ms | 215 ms | 228 ms |
| Verdict | slept and woke in ≈ 780 ms | never slept, because it was being poked every 50 s | slept and woke in ≈ 690 ms |
The wake is fast. We carried a known trap in from the earlier runs. Hibernated apps, which Cloud has scaled to zero while idle, returned 502 for ten to twenty seconds on the first request after idle. That did not reproduce at all. The first request took 972 ms and returned status 200, with no retry needed. Either the platform improved, or a small PHP application wakes much faster than the Rails and Rust ones did.
An open tab kept it awake, and it was our own doing. Thirteen presence refreshes in eleven minutes is one every fifty seconds, which is exactly upstream's refresh interval against a sixty-second connection TTL. The Rust sibling never slept because Action Cable pinged every three seconds. This one never slept because our own presence design polled over HTTP every fifty. When we moved the socket to managed Reverb, we removed the three-second ping and replaced it with a fifty-second one. That was better, but not good enough, which is the next section.
Postgres
We used the same method, pointed at an endpoint that must read a row, after eight minutes idle. That is long enough for both compute and Postgres to go away.
| ms | |
|---|---|
| Warm median | 211 |
| First request after 8 minutes idle | 1,969 |
| Immediately after | 214 |
Against the compute-only wake of 972 ms on an endpoint that touches nothing, the extra ≈ 1,000 ms is the serverless Postgres resuming. The two measurements use different endpoints, so it is not a clean separation, but the shape is clear. The database does suspend. Someone arriving at a fully asleep Campfire waits about two seconds for the first page, and then not at all.
There is one trap inside that row. Only the Dev preset ever suspends. Prod and Scale both set suspend_seconds to 0. The preset named for production is the one that never sleeps.
Presence without polling
The amber line had a fix, and the fix was not a tweak. It is done, and it is the most Laravel-shaped change in the whole experiment.
Presence polled because a managed Reverb cannot call the application. The CLI exposes no webhook configuration, so the application cannot learn that a browser left. The browser has to keep saying it is still there. But Reverb does know who is in a channel. It has to, because that is what makes member_added and member_removed work in the browser. It will also answer over the same Pusher HTTP API the application already uses to broadcast.
So we turned app/Support/Presence from a writer into a reader. It makes one call at the two moments the application actually needs the answer. One is when a new message decides whose unread marker to set. The other is when the notification job decides who to push to. The browser sends nothing on a timer. Joining the channel is the whole of "present", and leaving it is the whole of "absent". We moved clearing a room's own unread mark onto the room page load, which is a request that happens anyway. That left the two per-tab columns with no reader and no writer, so we dropped them in a migration.
We measured before and after. 13 requests in 11 minutes became 0 in 12 minutes, in a window with no deploy anywhere near it.
Here is a smaller correction to this page while we are here. In our first measurement, we attributed broadcasting/auth calls and sidebar refreshes to the idle tab as well. They are not periodic. That sample had page loads and our own probe traffic mixed into it. Counted per tab, both happen once at load and never again. It was always one timer and one endpoint. That makes the problem smaller than this page originally implied, and the fix no less necessary.
The honest cost is on the posting path. Measured from inside the datacentre, the Reverb lookup is 60 ms (median of five) against a message POST that takes 592 to 658 ms end to end. So it is roughly 10% of a message post, it is on the critical path, and a user waits for it. That is a real latency regression, traded for an application that sleeps, and we deliberately left it unoptimised. If it ever matters, the obvious move is a two-or-three-second cache of each room's member list, since a room's membership does not change between two messages sent seconds apart. But that puts a cache read back on the same path, so it is something to measure rather than assume.
When Reverb is unreachable, it fails open to "nobody is present", so unread marks and push notifications all go out. The alternative, reading an unreachable Reverb as "everyone is already here", silently swallows notifications, and a swallowed notification is the failure nobody can see.
The two smaller things in the same pass are also done. Message edit, delete, and boost are now live-verified rather than argued. We drove each one in a real browser with a second client watching, and each arrived over the socket with zero navigations.
We broadcast the sender's CSRF token to the whole room
This one is ours, it is a real defect, and upstream does not have it.
A Turbo Stream broadcast is a rendered fragment of HTML. In this port that fragment is rendered once, inside the sending user's own request, where the same ->render() produces the HTTP response and the thing that goes on the socket. It is then delivered to every other member of the room. Two partials reachable from that render emitted a session CSRF token. One was the quick-boost menu, which is eight forms each carrying one. The other was the boost-delete form.
We drove a real message POST through the kernel as one user and captured the broadcast it dispatched:
channel=rooms.11 bytes=8907
occurrences of the sender's CSRF token in the fragment broadcast to the room: 16
This is a disclosure rather than a takeover. Campfire's session cookie is set SameSite=lax, so the classic cross-site POST a stolen token would enable is already blocked by the cookie. Still, it is a value whose entire purpose is that nobody else knows it, and we handed it sixteen times to every other authenticated member of the room. That layer of defence simply was not there.
Upstream does not have it, and checking that is what makes this a finding rather than an embarrassment. Rails broadcasts through a detached renderer, which builds a fresh request with no session cookie on it. Rails still emits an authenticity token into that markup, but it is generated against an empty throwaway session and belongs to nobody. The leak is ours. It came from the port, specifically from rendering the broadcast inside the sender's request so that one render could serve both purposes. That is exactly the kind of thing a port does when it is trying to be faithful and fast at once, and exactly the kind of thing nothing tests.
The fix is that both partials now render token-free in every context, not conditionally on being broadcast. A partial that never carries a session token cannot leak one, whatever renders it. That is a fix to the class rather than to the two call sites. The forms still submit, because Turbo already attaches each viewer's own token as an X-CSRF-Token header, read from their own page's <meta> tag. No client-side change was needed at all.
The fix also broke the frame budget, which is why this is one change and not two. Removing the tokens took a typical fragment from 8,907 bytes to 7,388. That put it under the 8,000-byte inline budget for the first time, so messages stopped taking the gzip branch described earlier on this page. But that budget is measured against the raw fragment. What travels is the fragment JSON-encoded and then escaped again inside the Pusher envelope, and how much that inflates depends entirely on the content. A 7,842-byte plain-text fragment makes a 9,933-byte frame, which is 67 bytes under the ceiling. Add 120 fire emoji (480 bytes of HTML), and the frame grows by 2,144. So we moved the inline budget to 7,000, which is below the floor of a message fragment with no body in it at all. Every message goes back through gzip and lands under 3,000 bytes, exactly where it was before. A test with emoji-heavy and quote-heavy bodies guards that. The first version of the test used plain text only. It topped out 67 bytes under the cap and would have passed whether the budget was right or not.
No broadcast payload carries the actor's token, across posting, editing, boosting, unboosting, and deleting, and that property is mutation-verified. Putting the two partials back turns three of the six new tests red. The one rung we have not driven in a browser is a second viewer boosting from markup that arrived over the socket. We reproduced that server-side with CSRF enforcement forced back on, which is not the same as clicking it.
CI for a fork that had none, and ffmpeg in the build step
We made two passes and merged both. Each is worth a paragraph for a different reason.
CI
The fork arrived with no continuous integration at all. It now has five required jobs, all on PHP 8.5, which is what the live runtime reports. Branch protection is set to strict, so a pull request has to be up to date with main before it can merge.
| Job | What it runs |
|---|---|
tests |
the suite against a Postgres 18 service container |
pint |
formatting |
larastan |
static analysis at level 5 |
audit |
composer audit |
ffmpeg (linux/arm64) |
provisions the binary and runs the video group against it |
We picked the static-analysis level by measuring. Level 0 already reports 16 errors on this codebase, so a baseline is unavoidable at every level. The only real question is what the level buys. Level 5 reports 62. Level 6 reports 181, and the extra 119 are generics annotations on upstream model and collection code that upstream will never maintain. That is a large diff that finds no defect. So we chose level 5 and baselined the 62, all of them untyped-Eloquent noise rather than bugs. We also set a standing rule to fix an error rather than regenerate the baseline around it.
It earned its place the same day. In the ffmpeg pass, it caught Process::timeout() being called on Symfony's Process where the code should have used the Laravel facade. That was a guaranteed fatal error inside a build step, and nothing else would have found it before a deploy.
One trap is worth passing on, because it cost us ten minutes of staring at an empty checks list. GitHub creates no pull-request run at all for a branch that conflicts with its base, and neither the interface nor the CLI says that is why. "CI never started" can mean "this branch conflicts", not "CI is broken".
ffmpeg
The runtime has no ffmpeg, which is why this page originally said video posters were off and why the ledger row above has changed. It has one now, using the same method as our video renderer, Slate. The build step, which Cloud runs to package each deployment, downloads a single pinned static LGPL build. It checks the build against the release's own published SHA-256, discards everything except ffmpeg and ffprobe, and installs the pair inside the application root. The application root is the deploy artifact, so the pair goes wherever the artifact goes.
- The install goes in
base_path(). A sibling directory looks persistent on a live instance, but it is gone on the next deploy, because Cloud replaces the filesystem with each deployment. - The media code reads the configured directory before
PATH. There is no environment variable for anyone to set, and no dependence on the build having prepended anything toPATH, which is precisely what silently failed in the Rust sibling. A developer's ownffmpegstill answers when nothing is vendored. - The binary is arm64, because the pinned asset is per-architecture and the runtime is arm64. Provisioning the x86 build in CI would prove the wrong binary works.
The honest cost is +179.7 MB on every deploy artifact (291.2 MB extracted, trimmed to two binaries) and 8 seconds of build time. If that is too much for what it buys, the lever is dropping ffprobe, which is 90 MB of the 180. That loses video duration and dimensions but keeps posters.
We paid for one trap on the way. The pinned LGPL build has libopenh264 and no libx264, and Homebrew's build is the other way round. So a test fixture that hardcodes either one is really testing a build configuration. The fixture encodes mpeg4, which every build has. The tests check H.264 support separately by reading the decoder table, never with -h decoder=, which exits 0 for codecs that do not exist.
The binaries also have to be on both hosts, which is the finding. Cloud's managed queue runs jobs off the application instance, so checking the web container answers half the question. A bot webhook that replies with an mp4 creates an attachment inside a job, and that path calls both binaries. We added a --queue flag to the fork's campfire:doctor command. It dispatches a job that reports the worker's own hostname and resolved binary paths back through the one resource both hosts share. On Cloud, the two are demonstrably different instances with different pod names, and both resolve the vendored pair. Cloud ships the same artifact to the queue, which is why installing into the application root was the right call rather than a lucky one.
We also drove it in a browser on the live application, which is the rung that matters. We uploaded a two-second clip through the composer. The page rendered a <video> element with a poster attribute, and that poster URL returned 200 with 20,742 bytes of image/webp, with real RIFF/WEBP magic, out of the bucket. The timecode is the detail that makes it proof rather than a screenshot. The frame on screen reads 00:00:00.300, inside a <video preload="none">. The browser has not decoded anything. What you are looking at is the poster ffmpeg made during the upload.
What it costs
We derived these rates from this period's metered usage and extrapolated them to 730 hours.
| Line | ~Monthly |
|---|---|
| App compute, sleeping | ~$2–4, near $0 when genuinely idle |
| Serverless Postgres 18, Dev preset | ~$1–3 |
| Managed Reverb, 100 connections | ~$5.40, never sleeps |
| Managed queue, minimum 0 replicas | ~$0 idle |
| Bucket | ~$0 at this size |
| Total | ≈ $8–12/month |
The compute line is the one that moved. Before the presence pass, "genuinely idle" meant "nobody has the application open", which is not a state a chat application spends much of its day in. It now means nobody is typing. Vendoring ffmpeg costs 180 MB per build artifact and nothing per month.
Compared with the siblings, Rails costs ≈ $33/month, Rust ≈ $7/month, and this ≈ $8–12/month.
The Rails figure is dominated by an always-on Valkey, Cloud's Redis-compatible cache, plus an application that does not sleep. This one is dominated by Reverb, at an observed rate of about three-quarters of a cent per hour, billed by wall-clock time whether or not a single socket is connected. The Rust application is cheaper precisely because it carries its own socket server inside a compute instance that sleeps.
That is exactly the trade this experiment made, in the opposite direction, on purpose. Reverb is the one line where the Laravel way costs money. Everything else here is cheaper, simpler, and more honest than the hand-rolled version it replaced. The socket server is the one place where deleting 225 lines of Workerman and handing the job to a managed service converts a free thing into a floor on the bill. A connection-metered tier would change the economics of this exact shape of application, which scales to zero everywhere but still has a websocket.
What we would tell Laravel Cloud
In the order that cost us the most time.
- Scale-to-zero silently caps the environment at one replica.
min_replicas: 2is accepted, reads back as 2, and one container serves everything. Either reject the combination or say so in the response. - There is no way to ask whether an environment is currently asleep, and the obvious proxy is a trap. Cloud runs zeropod, so a slept pod keeps its name and a renamed container means a deploy. That is the opposite of what we assumed and published. A field on the environment, or one line in the system log at the moment of sleep, would have saved this page a correction.
cloud instance:update --scale-to-zero=falsecannot be used. It 422s on the sleep timeout with or without a timeout. The REST field works.- There is no bucket attach in the CLI at all. This is the third experiment in a row to report it.
environment:updatecan attach a database and a websocket application, but nothing for filesystem keys. cloud instance:sizeslists managed-queue sizes the API rejects, andmanaged-queue:createhardcodes one replica, so the CLI cannot create a queue that scales to zero in a single step.db-cluster:create --type=neon_serverless_postgresthrowsAttempt to read property "regions" on null. That is the value every existing cluster reports back. The accepted value has a version suffix. "Unknown type, try one of…" would have cost nothing.- Only the Dev Postgres preset suspends. Surface it in the preset description.
- A managed Reverb application's 10,000-byte frame limit is fixed and not exposed. Turbo Stream payloads do not fit. Either expose it or document it loudly, because every Turbo and Livewire user is walking toward it.
- There is no
tinkeron a deployed application, andcmd:runwith a bareaboutruns it as a shell command. Both make "what did this instance actually resolve?" needlessly hard, which is why this fork now ships acampfire:doctorcommand. repo:config -ncannot bootstrap a repository that has no application yet. Writing the organisation id into the config by hand unblocked it.- Reverb is billed by wall-clock hours and cannot sleep, which makes it the floor of the bill for an otherwise fully scale-to-zero application.
Credit where it is due, because this is the part that genuinely worked. Attaching a resource really does mean zero configuration in the application. Cloud sets environment variables for each attached resource, and the application picked up the database, the queue, the bucket, and Reverb without us setting a single variable by hand. Every driver resolved correctly on the first deploy. One thing to know is that QUEUE_CONNECTION is injected as cloud, not sqs. Anyone who "helpfully" sets that variable themselves shadows a connection name they could not have guessed.
What is next
The experiment answered "can it work?", so the question becomes "how Laravel-like can it get?", with a one-click install as the target. What follows is a plan, measured but not started. It is nine pull requests, and we have written no code yet.
JSON on the socket replaces rendered HTML. A typical message broadcasts 8,512 bytes of Turbo Stream HTML today. The same message as JSON is 566 bytes. That is fifteen times smaller raw, and nearly five times smaller than the gzipped HTML that currently ships. And 74% of that HTML is chrome, not content. The per-message options menu, which is eight quick-boost forms, is 6,067 bytes of an 8,230-byte fragment, while the message body itself is 265 bytes. It is identical for every message and for every viewer, and it belongs in the page once rather than in every broadcast. The real win is not the smaller size. The entire inline/gzip/pointer ladder described earlier on this page, the decompression path in the browser, and the frame budget the CSRF fix had to move all become dead code at the same moment.
A Blade template and Alpine carry the message stream, and Livewire carries everything else. Our first instinct was Livewire everywhere, and the fan-out numbers killed it. A broadcast that tells a hundred connected clients to re-render themselves is a hundred full-stack requests against an instance that may be cold. That is the same "the browser keeps calling the application" shape the presence pass just removed. So the stream renders its chrome once per page into a template and fills it from the JSON on the socket. Forms, settings, search, and the sidebar go to Livewire, where a round trip per interaction is already what happens. The one thing that would have made this hard turns out not to exist. There is nothing viewer-specific in the broadcast fragment to begin with, because own-message styling and the rest are already applied client-side from data attributes.
Tailwind comes through the fleet's nodeless standalone build. The repository has no package.json and no Node anywhere. The install story is composer install and migrate. Vite would add Node to that story, to the image, and to CI, for a frontend with one entry point. So the standalone binary builds the one stylesheet, and the output is committed, exactly as the Rails-compiled stylesheets are committed today. The look is also free to change. This is not a pixel-parity port, and where Tailwind's defaults beat what the port inherited, they win.
That is also what retires RailsCrypto, RailsCsrf, and the precompiled asset bundle, and it is where the last two "un-Laravel on purpose" entries finally go. Upstream is an experiment that will not be maintained, so exact compatibility with it is not a constraint we are choosing to keep.
This is the last Campfire experiment. Three runtimes, three bills, and one application that now does on Cloud what it was built never to do. It runs on more than one machine.