What causes "could not read dictionary: out of memory\n" in nodejs/node?

Free memory or increase the container/cgroup memory limit.

could not read dictionary: out of memory\n

Error message

could not read dictionary: out of memory\n

What it means

`malloc` for the dictionary buffer returned NULL — the process could not allocate `context->dictionary_size` bytes to hold the dictionary contents in memory. The file was successfully sized but the heap is exhausted or the allocation exceeds platform limits.

Solutions

Free memory or increase the container/cgroup memory limit.
Use a smaller dictionary file.
On 32-bit platforms, switch to a 64-bit build to enlarge the address space.
Check `ulimit -v` and `ulimit -d` and raise them if set low.

Defensive patterns

Strategy: validation

Validate before calling

#include <sys/sysinfo.h>
#include <stdbool.h>

bool enough_memory_for_dict(size_t dict_size) {
    struct sysinfo si;
    if (sysinfo(&si) != 0) return true; // can't check, proceed
    // Need at least dict_size + overhead of free RAM
    unsigned long long freeram = (unsigned long long)si.freeram * si.mem_unit;
    return freeram > dict_size * 2; // 2x safety margin
}

Prevention

Monitor free memory before running brotli with large dictionaries.
Raise container/cgroup memory limits if hitting OOM.
Use smaller dictionaries on memory-constrained devices.

When it happens

Trigger: System memory is exhausted; the dictionary size is large enough to fail `malloc` on a 32-bit build (near or above 2 GB); container memory cgroup limit hit; ulimit on data segment (`ulimit -d`) too low.

Common situations: Running brotli in a memory-constrained container or embedded device; processing a dictionary that is near the brotli maximum on a system with limited RAM; many concurrent brotli processes competing for memory.

Related errors

AI-assisted analysis of nodejs/node@1b2de5e052 (2026-08-13). Data as JSON: /api/errors/d287b41a05de64fe. Report an issue: GitHub.

Appendix: source

Thrown at deps/brotli/c/tools/brotli.c:918

  file_size_64 = FileSize(context->dictionary_path);
  if (file_size_64 == -1) {
    fprintf(stderr, "could not get size of dictionary file [%s]",
            PrintablePath(context->dictionary_path));
    fclose(f);
    return BROTLI_FALSE;
  }

  if (file_size_64 > kMaxDictionarySize) {
    fprintf(stderr, "dictionary [%s] is larger than maximum allowed: %d\n",
            PrintablePath(context->dictionary_path), kMaxDictionarySize);
    fclose(f);
    return BROTLI_FALSE;
  }
  context->dictionary_size = (size_t)file_size_64;

  buffer = (uint8_t*)malloc(context->dictionary_size);
  if (!buffer) {
    fprintf(stderr, "could not read dictionary: out of memory\n");
    fclose(f);
    return BROTLI_FALSE;
  }
  bytes_read = fread(buffer, sizeof(uint8_t), context->dictionary_size, f);
  if (bytes_read != context->dictionary_size) {
    free(buffer);
    fprintf(stderr, "failed to read dictionary [%s]: %s\n",
            PrintablePath(context->dictionary_path), strerror(errno));
    fclose(f);
    return BROTLI_FALSE;
  }
  fclose(f);
  context->dictionary = buffer;
  if (command == COMMAND_COMPRESS) {
    context->prepared_dictionary = BrotliEncoderPrepareDictionary(
        BROTLI_SHARED_DICTIONARY_RAW, context->dictionary_size,
        context->dictionary, BROTLI_MAX_QUALITY, NULL, NULL, NULL);
    if (context->prepared_dictionary == NULL) {

View on GitHub (pinned to 1b2de5e052)