v0.2.2 is now available! Download from GitHub | Install from OpenVSX | Visit Website
A VS Code extension for real-time visualization and optimization of Go struct memory layout. This GitHub repository provides a powerful golang tool for analyzing struct padding, alignment, and cache performance in your Go code.
This vscode-go extension shows you exactly how Go lays out structs in memory - byte offsets, alignment, padding, and cache line boundaries. It highlights wasteful padding in your golang structs and optimizes field ordering with one click, helping you reduce memory usage and improve performance.
- Reduce struct sizes by 10-30% without changing logic
- Better cache locality means better performance
- Learn how Go actually stores your data in memory
- See the impact of field ordering in real-time
- Inline annotations showing memory details for each field
- Byte offsets so you know exactly where fields live
- Size calculations and alignment requirements
- Padding detection with visual warnings
- NEW in v0.2: Nested struct support with recursive size calculation
- NEW in v0.2: Embedded field detection and analysis
- Color-coded warnings for excessive padding
- Cache line boundary detection (64-byte warnings)
- Hover tooltips with detailed breakdowns
- CodeLens buttons for one-click optimization
- Automatic field reordering by alignment and size
- Shows exact bytes saved before and after
- Preserves your comments and struct tags
- Safe refactoring that doesn't break anything
- NEW in v0.2: Works with nested and embedded structs
- NEW in v0.2: Export memory layout reports to JSON, Markdown, or CSV
- Detailed field-by-field analysis with offset, size, alignment, and padding information
- Architecture-specific reports for cross-platform analysis
- Perfect for documentation, code reviews, and performance audits
Supports amd64, arm64, and 386. Switch between them to see how pointer sizes affect layout.
- Open VS Code
- Press
Ctrl+P(Windows/Linux) orCmd+P(Mac) - Type:
ext install RhinoSoftware.go-memory-visualizer - Press Enter
Or visit the VS Code Marketplace
git clone https://github.com/1rhino2/go-memory-visualizer.git
cd go-memory-visualizer
npm install
npm run compile
code .
# Press F5 to launch Extension Development HostCreate or open any .go file with struct definitions:
type User struct {
Active bool // 1 byte + 7 padding
ID uint64 // 8 bytes
Name string // 16 bytes
Age uint8 // 1 byte + 7 padding
Balance float64 // 8 bytes
}The extension automatically shows:
// offset: 0 | size: 1 | align: 1 | padding: 7
Active bool
// offset: 8 | size: 8 | align: 8 | padding: 0
ID uint64
// Total: 48 bytes | Padding: 14 bytes (29% waste)
Click the CodeLens button above the struct:
Optimize struct - save 14 bytes (29% reduction)
type User struct {
ID uint64 // 8 bytes (no padding)
Balance float64 // 8 bytes (no padding)
Name string // 16 bytes (no padding)
Active bool // 1 byte (no padding)
Age uint8 // 1 byte + 6 final padding
}
// Total: 40 bytes | Padding: 6 bytes (15% waste)
// Saved 8 bytes (16.7% reduction)Access via Command Palette (Ctrl+Shift+P / Cmd+Shift+P):
| Command | Description |
|---|---|
Go: Show Memory Layout |
Display detailed memory breakdown for all structs |
Go: Optimize Struct Memory Layout |
Reorder fields in struct at cursor to minimize padding |
Go: Toggle Architecture |
Switch between amd64, arm64, and 386 |
Go: Export Memory Layout Report |
NEW in v0.2: Export struct analysis to JSON/Markdown/CSV |
Customize via VS Code Settings (Ctrl+, / Cmd+,):
{
// Default architecture for memory calculations
"goMemoryVisualizer.defaultArchitecture": "amd64",
// Show inline annotations above struct fields
"goMemoryVisualizer.showInlineAnnotations": true,
// Highlight fields with excessive padding
"goMemoryVisualizer.highlightPadding": true,
// Minimum padding bytes to trigger warning (default: 8)
"goMemoryVisualizer.paddingWarningThreshold": 8,
// Show warnings for cache line boundary crossings
"goMemoryVisualizer.showCacheLineWarnings": true
}| Setting | Type | Default | Description |
|---|---|---|---|
defaultArchitecture |
string | "amd64" |
Architecture for calculations: amd64, arm64, or 386 |
showInlineAnnotations |
boolean | true |
Display memory info above each field |
highlightPadding |
boolean | true |
Highlight fields with padding waste |
paddingWarningThreshold |
number | 8 |
Min padding bytes to show warning |
showCacheLineWarnings |
boolean | true |
Warn about 64-byte cache line crossings |
See examples/structs.go for demonstrations of:
- Well-optimized structs (minimal padding)
- Poorly-optimized structs (excessive padding)
- Common anti-patterns to avoid
- Best practices for field ordering
Before:
type APIResponse struct {
Success bool // 1 + 7 padding
Timestamp int64 // 8
Message string // 16
Code int32 // 4 + 4 padding
RequestID string // 16
}
// 56 bytes, 11 bytes wastedAfter:
type APIResponse struct {
Timestamp int64 // 8
Message string // 16
RequestID string // 16
Code int32 // 4
Success bool // 1 + 3 final padding
}
// 48 bytes, 3 bytes wastedImpact: 1M responses = 8 MB saved
The extension now automatically calculates memory layout for structs containing other custom structs:
type Point struct {
X float64 // 8 bytes
Y float64 // 8 bytes
}
type Rectangle struct {
TopLeft Point // 16 bytes (nested struct)
Width uint32 // 4 bytes
Height uint32 // 4 bytes
}
// Total: 24 bytesThe parser performs two-pass analysis:
- First pass: Register all struct definitions
- Second pass: Calculate layouts with nested struct sizes resolved
Embedded fields (promoted fields) are now properly detected and analyzed:
type Base struct {
ID uint64 // 8 bytes
CreatedAt int64 // 8 bytes
}
type User struct {
Base // embedded: 16 bytes
Name string // 16 bytes
Active bool // 1 byte + 7 padding
}
// Total: 40 bytesEmbedded pointers are also supported:
type Document struct {
*Metadata // embedded pointer: 8 bytes
Title string // 16 bytes
Published bool // 1 byte
}New command to export detailed struct analysis:
JSON Format: Machine-readable with full field details
{
"structs": [{
"name": "User",
"totalSize": 40,
"alignment": 8,
"totalPadding": 7,
"paddingPercentage": 17.5,
"fields": [...]
}],
"architecture": "amd64",
"exportedAt": "2025-11-23T12:00:00.000Z"
}Markdown Format: Human-readable documentation
## User
- **Total Size:** 40 bytes
- **Alignment:** 8 bytes
- **Total Padding:** 7 bytes (17.5%)
### Fields
| Field | Type | Offset | Size | Alignment | Padding After |
|-------|------|--------|------|-----------|---------------|
| ID | uint64 | 0 | 8 | 8 | 0 |CSV Format: Perfect for spreadsheets and data analysis
Struct,Field,Type,Offset,Size,Alignment,Padding After,Total Size,Total Padding,Padding Percentage,Architecture
User,ID,uint64,0,8,8,0,40,7,17.5,amd64
Usage:
- Open a Go file with struct definitions
- Run command:
Go: Export Memory Layout Report - Choose format: JSON, Markdown, or CSV
- Save to desired location
Perfect for:
- Code reviews and documentation
- Performance audits
- Cross-architecture analysis
- Team collaboration
The extension follows Go's alignment rules:
-
Type Alignment: Each type has an alignment requirement:
bool,int8,uint8: 1 byteint16,uint16: 2 bytesint32,uint32,float32: 4 bytesint64,uint64,float64: 8 bytes- Pointers, strings, slices: 8 bytes (amd64/arm64), 4 bytes (386)
-
Field Placement: Each field starts at an offset aligned to its requirement
-
Padding Insertion: Go adds padding bytes to satisfy alignment
-
Final Padding: Struct size is rounded up to largest field alignment
1. Extract all fields from struct
2. Calculate current layout and total size
3. Sort fields:
- Primary: by alignment (descending)
- Secondary: by size (descending)
4. Recalculate layout with new ordering
5. Compare sizes and show savings
Run the comprehensive test suite:
npm testTest Coverage:
- 33 unit tests across 3 modules
- Memory calculator (18 tests)
- Go parser (8 tests)
- Struct optimizer (7 tests)
- All architectures tested
- DEMO.md: Interactive demonstrations and visual examples
- DEVELOPMENT.md: Developer guide and architecture
- CHANGELOG.md: Version history and release notes
Contributions welcome! Please:
- Fork the repository
- Create a feature branch (
git checkout -b feature/amazing-feature) - Commit changes (
git commit -m 'Add amazing feature') - Push to branch (
git push origin feature/amazing-feature) - Open a Pull Request
git clone https://github.com/1rhino2/go-memory-visualizer.git
cd go-memory-visualizer
npm install
npm run compile
npm test- VS Code: 1.85.0 or higher
- Go files:
.goextension in workspace - Node.js: 20.x or higher (for development)
None for v0.2.0! Previous limitations resolved:
Nested struct support✅ Added in v0.2.0Embedded struct handling✅ Added in v0.2.0- Union type support (planned for v0.3.0)
See GitHub Issues for full list.
MIT License - see LICENSE file for details.
- Inspired by Go's memory layout documentation
- Built with VS Code Extension API
- Thanks to the Go community for feedback
- Issues: GitHub Issues
- Discussions: GitHub Discussions
- Contact: 1rhino2 on discord
- Nested struct support
- Embedded field handling
- Export layout reports
- Fixed export error handling
- Updated deprecated API usage
- Security fix: Patched path traversal vulnerability in export function
- Added path validation and normalization
- Implemented write verification and explicit file permissions
- Union type support
- Bitfield visualization
- Memory alignment profiler
- Integration with Go compiler
- Benchmark comparison tools
- Team collaboration features
Made for the Go community
Website • GitHub • Marketplace • Docs
![@github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=64&v=4){kind=small}