-
Notifications
You must be signed in to change notification settings - Fork 0
FAQ
Atomic Plugin is a code generation tool for JetBrains Rider that creates extension methods for the Atomic Framework - a reactive procedural game framework for C# and Unity.
The Atomic Framework is a game development framework that uses Entity-State-Behaviour pattern to reduce complexity in game interactions. It separates data from logic, uses reactive properties for state management, and promotes procedural programming for better performance.
- Framework Integration: Seamlessly works with Atomic Framework patterns
- Consistency: All entity operations follow Atomic Framework conventions
- Performance: Generated code uses aggressive inlining when needed
- Maintenance: Single source of truth for your entity API
- Type Safety: Full IntelliSense and compile-time checking
- Productivity: Automatic regeneration on changes
Yes, the Atomic Plugin is open-source and free to use under the MIT license.
Atomic requires JetBrains Rider 2025.1 or later.
No, Atomic is specifically designed for Rider and uses Rider-specific features.
Yes! Atomic has special support for Unity projects:
- Recognizes Unity project structure
- Handles .asmdef files
- Supports Unity types (Vector3, GameObject, etc.)
Rider will notify you of updates. To update:
- Go to
Settings→Plugins - Find Atomic in the Installed tab
- Click Update
- Restart Rider
The new editor notification panel makes generation easy:
- First time: Click the "Generate API" button in the notification panel
- Regenerate: Click "Regenerate API" when file already exists
-
Keyboard shortcut: Press
Ctrl+Shift+G - Quick actions: Use "Open Generated File" or "Delete Generated File" buttons
Starting from v0.1.4, auto-generation only works after initial manual generation:
- Control: You decide when to create new files
- Safety: Prevents accidental file creation
- Tracking: Sets up proper file tracking for auto-updates
-
Tags: Boolean flags (present or not). Example:
Player,Dead,Flying -
Values: Typed data attached to entities. Example:
Health: int,Position: Vector3
Yes! Any type available in your project can be used:
values:
CustomData: MyCustomClass
Config: GameConfiguration
Specify generic parameters with angle brackets:
values:
Items: List<Item>
Cache: Dictionary<string, object>
Grid: Cell[,]
No, each .atomic file generates one static class. Create multiple files for better organization:
-
Physics.atomic→PhysicsComponents.cs -
Combat.atomic→CombatComponents.cs
By default, in the same directory as the .atomic file. Use the directory property to customize:
directory: "Generated" # Relative to project
directory: "../Shared" # Parent directory
directory: "Assets/Scripts" # Specific path
When aggressiveInlining: true, the compiler is instructed to inline methods at call sites, eliminating method call overhead. Use for performance-critical code.
Enable unsafe: true when you need ref returns for direct memory access:
ref int health = ref entity.RefHealth();
health += 10; // Direct modificationUse with caution - only for performance-critical paths.
No, generation happens in the IDE before build. Generated files are normal C# files that compile quickly.
There's no hard limit, but for maintainability:
- Keep under 100 tags/values per file
- Split by feature or system
- Use multiple files for better organization
Check:
- Required fields present (
entityType,namespace,className) - No syntax errors (red underlines)
- File has
.atomicextension - Plugin is installed and enabled
- Check the
directoryproperty - Refresh project view
- Look in same folder as .atomic file (default)
- Check Event Log for errors
- Wait for project indexing to complete
- Build your project first
- Ensure types are referenced
- Try File → Invalidate Caches
It's recommended to:
- DO version control .atomic files
- DON'T version control generated .cs files
- Add generated files to .gitignore:
**/Generated/*.cs
**/*.generated.csCurrently, the generation template is fixed. Future versions may support custom templates.
Hash codes are deterministic based on tag/value names. The same name always produces the same hash across machines and sessions.
Yes, Atomic-generated files work with C# source generators. Generation order:
- Atomic generates .cs files
- Build picks up generated files
- Source generators process all code
Generated classes are static and cannot be partial. However, you can create extension methods in other files that work alongside Atomic-generated methods.
Yes! Generated code is normal C# that you can:
- Set breakpoints
- Step through
- View in debugger
- Profile
Recommended structure:
/Components
/Core
- Entity.atomic
- Transform.atomic
/Combat
- Health.atomic
- Weapons.atomic
/Physics
- Movement.atomic
- Collision.atomic
Many small files are better:
- Easier to maintain
- Better version control
- Clearer organization
- Faster regeneration
- Update .atomic file
- Regenerate code
- Fix compilation errors
- Use Find Usages to update all references
- Files:
Feature.atomic(e.g.,Player.atomic) - Classes:
FeatureComponentsorFeatureExt - Tags/Values: PascalCase (e.g.,
PlayerHealth)
Yes! Find the source at: https://github.com/Prylor/atomic-rider-plugin
Absolutely! We welcome:
- Bug reports
- Feature requests
- Pull requests
- Documentation improvements
git clone https://github.com/Prylor/atomic-rider-plugin.git
cd atomic-rider-plugin
./gradlew buildPluginReport issues at: https://github.com/Prylor/atomic-rider-plugin/issues
- Check Troubleshooting for technical issues
- Read Documentation for detailed guides
- Ask on GitHub Discussions
- Report bugs as GitHub Issues