---
# System prepended metadata

title: Solving Hardhat's "Memory Access Out of Bounds" Error

---

# Solving Hardhat's "Memory Access Out of Bounds" Error

## The Problem

When working with large Solidity projects containing multiple contracts, you might encounter this frustrating error while running `npx hardhat compile`:

![maob](https://hackmd.io/_uploads/Byj-88HZkg.png)

```
Memory access out of bounds
```

## Why Does This Happen?

Hardhat needs to load all contracts into memory before compilation. In projects with numerous or complex contracts, this can exceed the available memory, causing the compilation to fail. This is particularly common in:

- Projects with many inherited contracts
- Complex DeFi protocols
- Large-scale dApp backends
- Monorepo structures with multiple related contracts

## The Solution: Incremental Compilation

You can solve this by compiling your contracts incrementally, leveraging Hardhat's caching mechanism. Here's how:

### 1. Configure the Compilation Path

In your `hardhat.config.js` or `hardhat.config.ts`, modify the `paths` configuration:

```javascript
module.exports = {
  // ... other config options
  paths: {
    sources: './path/to/specific/folder',
  },
};
```

### 2. Follow a Bottom-Up Compilation Strategy

For a project structure like this:

```
contracts/
├── core/
│   ├── tokens/
│   └── governance/
└── periphery/
    ├── adapters/
    └── interfaces/
```

Follow this compilation order:

1. Start with the deepest nested folders
2. Move up one level at a time
3. Finally compile the root contracts

### Example Compilation Steps

```bash
# Step 1: Compile deepest folders first
# Update hardhat.config.js with:
paths: { sources: './contracts/core/tokens' }
npx hardhat compile

# Step 2: Move up one level
paths: { sources: './contracts/core' }
npx hardhat compile

# Step 3: Compile periphery folders
paths: { sources: './contracts/periphery' }
npx hardhat compile

# Step 4: Finally, compile everything
paths: { sources: './contracts' }
npx hardhat compile
```

## Best Practices

1. **Organize Your Contracts**: Group related contracts in logical folders to make incremental compilation easier.

2. **Leverage Caching**: Hardhat caches compilation results, so previously compiled contracts won't need to be recompiled unless modified.

3. **Monitor Memory Usage**: If you're still having issues, consider:
   - Increasing Node.js memory limit: `export NODE_OPTIONS=--max_old_space_size=4096`
   - Breaking down extremely large contracts into smaller ones
   - Using interfaces to reduce the compilation load

## Troubleshooting

If you still encounter issues:

- Clear the cache using `npx hardhat clean`
- Ensure you're using the latest version of Hardhat
- Check for circular dependencies in your contracts
- Consider splitting your project into multiple packages

## Conclusion

While the "Memory access out of bounds" error can be frustrating, using incremental compilation is an effective solution that works well with Hardhat's caching system. This approach not only solves the memory issue but can also lead to better project organization and faster development cycles.