NeroSpec

Create rules to check if your Revit model data meets your standards, then run checks to see what passes and what needs fixing.

What It Does

NeroSpec helps you make sure everyone on your team is entering data correctly. You create rules (like "All rooms must have a name" or "Fire rating must be filled in"), organize them into groups, and then check your model to see what passes and what fails. It's like spell-check, but for your BIM data.

Key Benefits

  • Enforce Standards: Make sure data is entered correctly and consistently
  • Save Time: Check thousands of elements automatically instead of manually
  • See Details: Know exactly which elements fail and why
  • Track Progress: See improvement over time
  • Share Rules: Use the same standards across all your projects

The Five Parts

NeroSpec has five main sections you'll use:

1. Rule Editor - Create individual rules - Make rules for what data should look like - Example: "Room name cannot be empty"

2. Ruleset Manager - Group rules together - Combine related rules - Example: "Room Data Requirements" ruleset with 10 rules about rooms

3. Rule Schema Manager - Build complete checks - Combine rulesets for a full quality check - Example: "Floor Plan Deliverable" schema with room, wall, and door rulesets

4. Rule Executor - Run the checks - Check your model against your schemas - See what passes and fails - Get detailed results

5. Execution History - Review past checks - See previous validation runs - Track improvements over time - Compare results

How to Use

Creating Your First Rule

Step 1: Open Rule Editor 1. Click NeroSpec on the NeroScale ribbon 2. Choose "Rule Editor" from the menu 3. You'll see the rule creation form

Step 2: Fill in Rule Details - Name: Give it a clear name (e.g., "Room Name Required") - Category: Pick what type of element (e.g., Rooms) - Parameter: Which field to check (e.g., Name) - Operator: How to check it (e.g., "Not Empty") - Expected Value: What you want to see (if needed) - Warning Level: How serious (Error, Warning, or Info) - Description: Explain why this rule exists

Step 3: Save the Rule - Click "Save Rule" - Your rule appears in the saved rules list - You can now use it in rulesets

Building a Ruleset

Step 1: Open Ruleset Manager - Go to "Ruleset Manager" - Click "Create Ruleset"

Step 2: Name Your Ruleset - Give it a clear name (e.g., "Room Requirements") - Add a description explaining what it checks - Choose AND or OR: - AND = All rules must pass - OR = At least one rule must pass

Step 3: Select Rules - Check the boxes next to rules you want - Use the search to find rules quickly - Click "Select All" to include everything

Step 4: Save - Review your selections - Click Save - Your ruleset is ready to use

Creating a Schema

Step 1: Open Rule Schema Manager - Go to "Rule Schema Manager" - Click "Create Rule Schema"

Step 2: Fill in Schema Info - Name: What you're checking (e.g., "Design Development Check") - Description: When to use this schema - Version: Start with 1.0 - Operator: AND or OR for combining rulesets - Author: Your name - Contact: Your email

Step 3: Select Rulesets - Pick which rulesets to include - You can select multiple rulesets - Each ruleset has its own rules

Step 4: Save Schema - Click Save - Schema is ready to run

Running a Validation

Step 1: Open Rule Executor - Go to "Rule Executor" - See your available schemas

Step 2: Select Schema - Check the box next to schemas you want to run - You can run multiple at once - See how many rules are in each

Step 3: Run It - Click "Run validation" - Watch the progress bar - Wait for it to finish

Step 4: Review Results You'll see: - How many passed - How many failed - Total warnings and errors

Step 5: See Details - Click "Open detail" on any schema - See which elements failed - Click on an element to see which specific rules it failed - See what was expected vs. what was found

Checking History

Step 1: Open Execution History - Go to "Execute history" - See all past runs (newest first)

Step 2: Pick a Run - Click on a past validation - See which schemas were run - View the results

Step 3: Review Details - Look at passed and failed elements - See specific rule failures - Compare to recent runs

Understanding Operators

For Checking Data

Not Empty - Field must have something in it - Use for required information

Equals - Must match exactly - Use for specific values (e.g., "Approved")

Greater Than / Less Than - For numbers - Use for size limits, ratings, counts

Contains - Text must include something - Use for partial matches

Matches Pattern - Advanced text checking - Use for formatted codes (e.g., room numbers)

For Combining Rules

AND - Everything must pass - Strict checking - Use when all requirements are mandatory

OR - At least one must pass - More flexible - Use when you have alternatives

Warning Levels

Error (Red) - Critical issues - Must be fixed - Blocks project milestones - Example: Missing fire rating

Warning (Yellow) - Important but not critical - Should be addressed - Doesn't block progress - Example: Missing manufacturer info

Info (Blue) - Nice to have - Optional improvements - Best practice recommendations - Example: Add product URL

Tips for Success

Creating Good Rules

  • Use clear, simple names everyone understands
  • Write helpful descriptions
  • Start with a few critical rules
  • Add more rules over time

Organizing Rulesets

  • Group related rules together
  • Don't make rulesets too big (5-15 rules is good)
  • Use descriptive names
  • Document when to use each ruleset

Running Checks

  • Run regularly (weekly is good)
  • Check before big deadlines
  • Start with one schema, add more later
  • Review results with your team

Fixing Issues

  • Fix errors first
  • Work through warnings next
  • Use info items as goals
  • Document why some failures are okay

Common Uses

Quality Gates

Before submitting work: - Run your standard schema - Fix all errors - Address important warnings - Document known issues

Data Cleanup

Improving model quality: - Find all empty parameters - Check naming consistency - Verify required information - Standardize formatting

Team Standards

Keep everyone aligned: - Create company-wide rules - Share schemas across projects - Train new team members with validation results - Measure compliance over time

Client Deliverables

Meet client requirements: - Build schema matching client requirements - Check before delivery - Provide validation report - Show compliance

Common Questions

How many rules should I create? Start with 5-10 important ones. Add more as you go. Too many at once is overwhelming.

Can I share rules with others? Yes! Export rules, rulesets, or schemas as files and share them.

What if I want to change a rule? Edit it in Rule Editor. The changes apply immediately to all rulesets using it.

Do validations change my model? No, they only read and report. You still need to fix issues yourself.

Can I run checks automatically? Not built-in, but you can set reminders to run them regularly.

What if most elements fail? That's okay! It shows you what needs work. Start by fixing the most important items.

Use With Other Tools

  • ParameterTransfer: Fix parameter values after validation finds issues
  • ModelHealthCheck: Check model health before running validations
  • Schedule Excel: Export schedules, fix data in Excel, then re-validate

Where to Find It

  1. Open Revit
  2. Look for the NeroScale ribbon
  3. Click "NeroSpec"
  4. Choose which section you need from the menu on the left

NeroSpec

Define, manage, and enforce specification-driven validation rules across Revit projects with comprehensive rule management, execution, and reporting.

Overview

NeroSpec is a powerful specification management and validation system that enables teams to define data quality rules, organize them into rulesets and schemas, execute validation checks, and track compliance over time. Built on a modern MVVM architecture with a sophisticated UI, NeroSpec provides end-to-end workflows for BIM data compliance.

Key Features

  • Rule Editor: Create and manage individual validation rules
  • Ruleset Manager: Organize rules into logical collections
  • Rule Schema Manager: Build complete validation schemas from rulesets
  • Rule Executor: Run validations and review detailed results
  • Execution History: Track validation runs and analyze trends over time
  • Multi-Level Operators: AND/OR logic at rule, ruleset, and schema levels
  • Flexible Validation: Support for multiple operators and warning levels
  • Comprehensive Reporting: Detailed pass/fail results with element-level details
  • Import/Export: Share rules, rulesets, and schemas across projects
  • Pagination: Efficient handling of large validation results

Architecture

Five Core Modules

1. Rule Editor - Create individual validation rules - Define parameter checks and conditions - Set warning levels (Error, Warning, Info) - Support for multiple operators (Equals, Greater Than, Pattern Matching, etc.)

2. Ruleset Manager - Group related rules into rulesets - Set ruleset-level operators (AND/OR) - Assign severity levels to rulesets - Manage ruleset descriptions and metadata

3. Rule Schema Manager - Combine rulesets into comprehensive schemas - Schema-level AND/OR operators - Version control for schemas - Author and contact information tracking

4. Rule Executor - Execute schemas against active Revit document - Real-time validation progress tracking - Detailed pass/fail reporting - Element-level result inspection - Export execution history

5. Execution History - Review past validation runs - Compare results over time - Element-level detail drilling - Historical trend analysis - Paginated result browsing

Rule Structure

Rules

Individual validation checks defined by: - Name: Descriptive rule identifier - Category: Revit category (e.g., OST_Walls, OST_Doors) - Parameter: Target parameter to validate - Operator: Validation logic (Not Empty, Equals, Greater Than, etc.) - Expected Value: The value to compare against - Unit: Optional unit specification - Warning Level: Error, Warning, or Info - Description: Detailed explanation of the rule

Rulesets

Collections of rules with: - Name: Ruleset identifier - Description: Purpose and scope - Operator: How rules are combined (AND/OR) - Level: Severity level - Rules: Selected rules included

Schemas

Complete validation frameworks with: - Name: Schema identifier - Description: Overall purpose - Version: Schema version number - Schema Version: Specification version - Operator: How rulesets are combined (AND/OR) - Author: Creator information - Contact: Support contact - Rulesets: Included rulesets

Workflows

Create Validation Rules

  1. Open Rule Editor
  2. Navigate to Rule Management → Rule Editor

  3. Review existing rules in the saved rules list

  4. Define New Rule

  5. Enter rule name (e.g., "Room Name Required")
  6. Select Revit category (e.g., OST_Rooms)
  7. Specify parameter to check (e.g., "Name")
  8. Choose operator (e.g., "Not Empty")
  9. Set expected value if applicable
  10. Add unit if needed
  11. Select warning level

  12. Write clear description

  13. Save Rule

  14. Click Save Rule button
  15. Rule appears in saved rules list

  16. Available for use in rulesets

  17. Manage Rules

  18. Edit existing rules
  19. Copy rules to create variants
  20. Delete obsolete rules
  21. Search and filter rules

Build Rulesets

  1. Open Ruleset Manager
  2. Navigate to Rule Management → Ruleset Manager

  3. Review existing rulesets

  4. Create New Ruleset

  5. Click Create Ruleset
  6. Enter ruleset name
  7. Write description
  8. Select operator (AND/OR)

  9. Choose severity level

  10. Select Rules

  11. Browse available rules
  12. Use filters to find relevant rules
  13. Select individual rules or select all

  14. Review selection count

  15. Save Ruleset

  16. Confirm ruleset configuration
  17. Save to library

  18. Ruleset available for schemas

  19. Manage Rulesets

  20. Edit existing rulesets
  21. Copy rulesets
  22. Delete rulesets
  23. Export/import ruleset definitions

Create Schemas

  1. Open Rule Schema Manager
  2. Navigate to Rule Management → Rule Schema Manager

  3. View existing schemas

  4. Define Schema

  5. Click Create Rule Schema
  6. Enter schema name and description
  7. Set schema version and version number
  8. Select schema-level operator (AND/OR)

  9. Add author and contact information

  10. Select Rulesets

  11. Browse available rulesets
  12. Filter by operator or level
  13. Select rulesets to include

  14. Use "Select All" for quick selection

  15. Save Schema

  16. Review schema configuration
  17. Save to schema library

  18. Schema ready for execution

  19. Manage Schemas

  20. Edit schemas
  21. Delete obsolete schemas
  22. Export/import schemas
  23. Version tracking

Execute Validations

  1. Open Rule Executor
  2. Navigate to Rule Management → Rule Executor

  3. View available schemas

  4. Select Schemas

  5. Browse schema library
  6. Filter by name
  7. Select schemas to execute

  8. Review rule counts

  9. Run Validation

  10. Click "Run validation" button
  11. Monitor real-time progress
  12. View execution status

  13. Wait for completion

  14. Review Results

  15. View overall statistics (passed/failed/warnings/errors)
  16. See summary for each schema
  17. Browse element-level results

  18. Inspect specific failures

  19. Drill into Details

  20. Click "Open detail" on any schema
  21. Switch between failed and passed elements
  22. Use pagination to browse large result sets
  23. Select element to see rule-by-rule results

  24. Review actual vs. expected values

  25. Save History

  26. Execution automatically saved to history
  27. Results available for future reference
  28. Supports trend analysis

Review History

  1. Open Execution History
  2. Navigate to Rule Management → Execute history

  3. View list of past validation runs

  4. Browse Runs

  5. Runs listed newest first
  6. See run date, document name, summary
  7. View schemas executed in each run

  8. Check overall pass/fail status

  9. Inspect Results

  10. Select a run from history
  11. View schemas that were executed
  12. Select a schema to see detailed results
  13. Paginated element browsing

  14. Rule-level detail inspection

  15. Delete Old Runs

  16. Remove outdated history entries
  17. Maintain history hygiene
  18. Free up storage space

Operators

Validation Operators

  • Not Empty: Parameter must have a value
  • Equals: Parameter matches exact value
  • Not Equals: Parameter doesn't match value
  • Greater Than: Numeric parameter exceeds value
  • Less Than: Numeric parameter below value
  • Matches Pattern: Text matches regex pattern
  • Contains: Text contains substring

Logical Operators

AND (All must pass) - All rules/rulesets must pass - Strictest validation - Use for critical requirements

OR (Any can pass) - At least one rule/ruleset must pass - More lenient validation - Use for alternative compliance paths

Warning Levels

Error - Critical compliance issues - Must be resolved - Blocks project milestones

Warning - Important but non-critical - Should be addressed - May impact quality

Info - Informational notices - Best practice recommendations - Optional improvements

Best Practices

Rule Design

Clear Naming - Use descriptive, searchable names - Include category and parameter - Indicate validation type - Example: "Room_Name_Required"

Comprehensive Descriptions - Explain why rule exists - Document expected behavior - Provide resolution guidance - Include examples

Appropriate Operators - Choose operator that matches intent - Use "Not Empty" for required fields - Use patterns for format validation - Use comparisons for numeric limits

Ruleset Organization

Logical Grouping - Group related rules together - Organize by discipline or system - Create focused, purposeful rulesets - Avoid overly large rulesets

Clear Hierarchy - Use AND for strict requirements - Use OR for alternatives - Document operator choice rationale - Test operator behavior

Schema Development

Comprehensive Coverage - Include all relevant rulesets - Cover all project requirements - Balance breadth and specificity - Version schemas as requirements evolve

Progressive Validation - Start with critical rules - Add rules incrementally - Test schemas before full deployment - Refine based on feedback

Execution Strategy

Regular Validation - Schedule periodic checks - Validate before milestones - Run after major changes - Track trends over time

Targeted Validation - Select relevant schemas for task - Don't always run all schemas - Focus on current concerns - Save execution time

History Management

Review Trends - Compare runs over time - Identify recurring issues - Measure improvement - Share progress with team

Archive Management - Delete obsolete runs periodically - Keep representative history - Export important results - Balance storage and retention

Common Use Cases

BIM Execution Plan Compliance

Create schemas enforcing BEP requirements: - Required parameter population - Naming convention validation - Classification code format - LOD-specific requirements

Quality Assurance

Establish quality gates: - Pre-submission validation - Coordination check requirements - Data completeness verification - Standard compliance confirmation

Data Handover

Ensure clean data delivery: - COBie requirements - Client data requirements - Facility management data - Asset information validation

Design Standards

Enforce firm standards: - Drawing naming conventions - View template compliance - Family naming standards - Parameter standardization

Discipline Coordination

Validate coordination requirements: - Space naming consistency - Level naming alignment - Grid line correspondence - Unit consistency

Integration

Works With

Import/Export

Rule Export/Import

Share individual rules: - Export rules to JSON files - Import rules from other projects - Build rule libraries - Standardize across organization

Ruleset Export/Import

Share ruleset configurations: - Export complete rulesets - Import standard rulesets - Maintain consistency - Version control rulesets

Schema Export/Import

Distribute validation frameworks: - Export schemas as JSON - Share across projects - Implement company standards - Version control schemas

Parameter Filter Import

Leverage existing filters: - Import Revit parameter filters as rules - Convert view filters to rulesets - Accelerate rule creation - Reuse existing logic

Advanced Features

Pattern Matching

Use regex for format validation: - Room numbering schemes - Door/window tags - Classification codes - Custom identifiers

Pagination

Handle large result sets: - 50 elements per page - Quick page navigation - Efficient memory usage - Smooth performance

Execution Snapshots

Complete validation records: - All rules and results saved - Element details preserved - Historical comparison enabled - Audit trail maintained

Troubleshooting

Rules Not Working

Check Category Match - Verify category is correct - Ensure elements exist in that category - Check category spelling

Verify Parameter Exists - Confirm parameter name is exact - Check parameter is accessible - Verify parameter type

Performance Issues

Large Rule Sets - Break into smaller schemas - Run targeted validations - Use appropriate scope - Optimize rule logic

Many Elements - Use pagination efficiently - Filter by category - Consider batch processing - Close unnecessary applications

Import Failures

File Format - Ensure JSON is valid - Check file encoding - Verify structure matches schema - Review error messages

Tips and Tricks

  • Start Small: Begin with a few critical rules and expand
  • Test First: Validate rules on small element sets before full runs
  • Document: Use descriptions liberally - future you will thank you
  • Version: Keep track of schema versions as requirements evolve
  • Share: Export successful rulesets to share with team
  • Iterate: Refine rules based on execution feedback
  • Compare: Use history to track improvement over time
  • Filter: Use search and filters to find rules/rulesets quickly

Requirements

Prerequisites

  • Autodesk Revit (2024+)
  • NeroScale add-in installed and loaded
  • Project document open (not family documents)

Permissions

  • Read access to validate elements
  • Write access to save rules/rulesets/schemas
  • Appropriate permissions to modify elements (for fixing issues)

Learn More

  • BIM data standards and specifications
  • Regular expression syntax for pattern matching
  • Revit parameter fundamentals
  • BIM Execution Plan (BEP) development
  • COBie and data handover requirements
  • Quality assurance in BIM workflows

FAQ

Can specs be shared? Yes, export/import rules, rulesets, and schemas via JSON files.

How many rules can a ruleset contain? No hard limit, but keep rulesets focused (typically 5-20 rules) for maintainability.

Can I validate linked models? Currently validates active document only. Open linked models separately.

What's the difference between AND and OR operators? AND requires all items to pass; OR requires at least one item to pass.

How long are history records kept? Indefinitely until manually deleted. Manage storage by periodically cleaning old runs.

Can I schedule automatic validations? Not built-in, but can be scripted using Revit API for automated workflows.

Do validations modify the model? No, NeroSpec only reads and validates. Use other tools to fix identified issues.

Can I export validation results? Yes, execution history can be exported to JSON for external processing and reporting.