Gleam Build Profiles: Transitioning from Dev to Prod for Erlang Targets

Answer to the Core Questions

1. Does the prod profile add BEAM optimization flags that can alter tail‑call behavior?

Yes. In a prod build Gleam passes the Erlang compiler flags +native and, for BEAM targets, +{hipe,[o3]} (or a similar HiPE level depending on the OTP version). These enable native code generation and aggressive inlining. While the BEAM’s fundamental last‑call elimination remains active, the inlining can increase per‑call stack usage and, in extreme cases, shift the point at which the process stack limit is hit.

2. How to verify stack safety in a production build without relying on dev debug metadata?

Run a dedicated stress test that exercises the recursive function to a depth far beyond typical usage, monitor for system_limit errors, and optionally trace call depth with erlang:trace/3. The test should be performed on a prod‑built binary and, if needed, with the process stack size increased via the +P flag to confirm that the observed depth isn’t limited by defaults.

Practical Verification Steps

1. Inspect the exact compiler flags: Run gleam build -t prod -v or set GLEAM_LOG=debug and capture the erlc command line. Confirm the presence of +native and +{hipe,…}.
2. Build the production binary: gleam build -t prod.
3. Run a recursion stress test: Use a test harness that calls the recursive function with a depth at least 10× the maximum depth used in dev. Watch the Erlang shell for system_limit or error_logger messages.
4. Optional – trace call depth: In the shell, invoke

   erlang:trace(self(), true, [call]).
       % run the recursive function
       erlang:trace(self(), false, [call]).
   

   Collect the trace events to compute the maximum call depth. Ensure it stays below ~80% of the configured process stack size.
5. Adjust stack size if needed: If the test fails, rebuild with a larger stack via +P 32768 (or a value appropriate for your OTP). Repeat the test.
6. Optional – disable aggressive inlining: If you need to match dev stack usage, add to gleam.toml:

   [[profile.prod]]
       erl_opts = ["+{inline,[{max_size,0}]}"]
   

   This prevents the compiler from inlining recursive calls.

What Next?

To tailor these steps to your environment, I need to know which Erlang/OTP version you’re targeting. The exact HiPE level and native code flags can differ between releases, affecting the recursion depth that is safe.

Missing Diagnostic Detail

Which Erlang/OTP version is your project built against?