What's New In Revit API 2027?

Revit has been updated to use .NET 10 at runtime.

There are some minor breaking changes since .NET 8, see:

• https://learn.microsoft.com/en-us/dotnet/core/compatibility/10.0
• https://learn.microsoft.com/en-us/dotnet/core/compatibility/9.0

You may need to update your "global.json", if you have one.

"sdk": {
    "version": "10.0.100",
    "rollForward": "minor"
}

See https://learn.microsoft.com/en-us/dotnet/core/tools/global-json

A new API was added to provide more control over add-in isolation settings. In the RevitAddInUtility API

The new types:

• AddInDependencyBase - The abstract base class for representing a manifest context dependency entry.

• ClientIdDependency - Represents a dependency on another context by specifying a ClientId (GUID) of an Add-in that is loaded to that context.

• ContextNameDependency - Represents a dependency on another Add-in context, referenced by its context name.

The new properties:

• AddInDependencyBase.AssemblyNames - Represents optional list of assembly names with extension to resolve from the dependent context.

• ClientIdDependency.ClientId - The GUID of the Add-in item from the dependent context.

• ContextNameDependency.ContextName - Represents the name of the dependent context.

The new methods:

• ClientIdDependency.ClientIdDependency() - A constructor that initializes a new instance of the ClientIdDependency class with the referenced client identifier.

• ContextNameDependency.ContextNameDependency() - A constructor that initializes a new instance of the ContextNameDependency class with the referenced context name.

The new properties:

• UseAllContextsForDependencyResolution - Controls whether Revit will resolve the Add-in dependencies using public assemblies from all contexts or only from its declared dependencies.

• PublicAssemblies - Represents a list of assemblies that this Add-in context is willing to share with other Add-in contexts.

• Dependencies - Represents a list of declared dependencies that specify preferred sources for resolving shared public assemblies.

Sample use of the manifest file:

<?xml version="1.0" encoding="utf-8"?>
<RevitAddIns>
    <AddIn Type="Application">
        <Assembly><Path to your Addin installation directory>\Plugin.dll</Assembly>
        <ClientId>00000000-0000-0000-0000-000000000000</ClientId>
        <FullClassName>Plugin.App</FullClassName>
        <Name>Test Plugin</Name>
        <VendorId>VendorName</VendorId>
        <VendorDescription>Vendor description</VendorDescription>
    </AddIn>
    <ManifestSettings>
        <!-- The default value is True. If this property is not explicitly set to False, the Add-in will run in the Default context. -->
        <UseRevitContext>False</UseRevitContext>
        <!-- An optional property to specify a context name for your Add-in. If this option is missing, the full path to the Add-in DLL will be used for ContextName. ContextName is useful if several different Add-ins need to be loaded to the same isolated context (by specifying the same ContextName). Also, it can be used to reference the Add-in context when declaring a dependency on the context with this Add-in. -->
        <ContextName>MyPluginContextName</ContextName>
        <!-- The default value is False. If set to True, all registered Public Assemblies from all contexts will be used during dependency resolution. Dependencies declared in the <Dependencies> section will be prioritized and checked first. -->
        <UseAllContextsForDependencyResolution>True</UseAllContextsForDependencyResolution>
        <!-- PublicAssemblies - Optional node with lists of assemblies that this Add-in context is willing to share with other Add-in contexts.
             These assemblies will only be shared if the requesting Add-in doesn't ship its own copy. -->
        <PublicAssemblies>
            <!-- Assembly - Path to the public assembly that the add-in context wants to share. -->
            <Assembly>..\MyAddInFolder\Plugin.API.dll</Assembly>
            <Assembly>D:\MyAddInFolder\Plugin.Service.API.dll</Assembly>
        </PublicAssemblies>
        <!-- Dependencies - An optional node that defines a prioritized list of other Add-in contexts that this Add-in prefers to resolve shared public assemblies from. Two types of Dependencies are supported: DependsOnClientId and DependsOnContext. The Add-in may declare dependencies on multiple contexts. -->
        <Dependencies>
            <!-- DependesOnClientId node with the ClientId - GUID of the Add-in item from the context that this Add-in has a dependency on. This could be used to reference the context of the dependent Add-in if it doesn't have ContextName specified.
                 For example, if the plugin has 2 or more Add-in items (Application, DBApplication, Command) in the manifest, then the GUID of any of these will work to reference the dependent Add-in context. -->
            <DependsOnClientId ClientId="11111111-1111-1111-1111-111111111111">
                <!-- AssemblyName - an optional attribute that specifies names of assemblies that are expected to be resolved from this context.
                     If no AssemblyName is specified - all public assemblies from this context will be used for assembly resolution for your Add-in; otherwise, only listed assemblies will be resolved from this context. -->
                <AssemblyName>Plugin2.API.dll</AssemblyName>
                <AssemblyName>Plugin2.Service.API.dll</AssemblyName>
            </DependsOnClientId>
            <!-- Alternatively, the DependsOnContext node with the ContextName attribute could be used to reference the context.-->
            <DependsOnContext ContextName="Default">
                <AssemblyName>SomeDLL.API.dll</AssemblyName>
            </DependsOnContext>
        </Dependencies>
    </ManifestSettings>
</RevitAddIns>

For improved security, the location that Revit looks for add-ins installed for “all users” has changed.

The per-user locations for add-in installation are still supported.

This change affects the logic for Revit loading of add-ins at startup or while the session is running. In addition, this results in a change to the value returned by:

• Application.AllUsersAddinsLocation

For similar reasons, the location of the AdminSettings.json file has been updated.

With the introduction of more region options, built in properties to access regions have been replaced with a routine to access all the available regions:

The thermal analysis APIs have been updated to incorporate more standardized terminology for expressing heat transfer values. The following changes have been made:

This new property reflects standard thermal transmittance terminology and is now available on the following classes:

• Autodesk.Revit.DB.Analysis.EnergyAnalysisConstruction

• Autodesk.Revit.DB.Analysis.EnergyAnalysisSurface

• Autodesk.Revit.DB.Analysis.EnergyAnalysisOpening

• Autodesk.Revit.DB.ThermalProperties

• Autodesk.Revit.DB.FamilyThermalProperties

The following members are deprecated and may be removed in later version of Revit:

IFCUserDefinedPropertySet.GetApplicableEntities()

The AXM import functionality has been deprecated in Revit 2027 and will be removed in a future release. This deprecation is due to the discontinuation of FormIt as of the 2024 product line.

The following members are marked as deprecated and may be removed in later version of Revit:

The following APIs have been deprecated as part of enum consolidation and constraint validation cleanup.

With the automatic migration of legacy HVAC Zone elements to System-Zones, the following class is deprecated and should not be used in Revit 2027:

The following property name is corrected:

The following API is marked as deprecated and may be removed in later version of Revit:

Access to analytical shading surfaces has been consolidated to reduce the number of specialized retrieval methods.

This change unifies analytical surface access and aligns shading surfaces with the broader analytical surface API.

Several legacy members on EnergyDataSettings have been deprecated as part of an effort to simplify and modernize energy data configuration.

These members previously exposed low-level configuration values related to ventilation, glazing, shading, schedules, and HVAC assumptions. Developers should expect these settings to be managed through higher-level energy analysis workflows rather than direct property access.

In addition, some enumerated types have been replaced with clearer values:

Energy analysis surface type identification has been aligned more closely with gbXML conventions.

This change improves consistency when working with analytical surfaces intended for export or interoperability scenarios.

The following members are deprecated and may be removed in later versions of Revit:

The parameter representing the host of a family instance has changed. The new parameter, INSTANCE_FREE_HOST_ID will return a valid ID if the 'Host' exists; otherwise, returns an invalid ID if the 'Host' does not exist or the Family Instance is 'Orphaned':

The parameter values associated with tag IndependentTag parameters have undergone renaming in the API. The new parameter TAG_LEADER_START_TYPE represents if the leader start has "Free Start" or "Attached Start". The new parameter TAG_LEADER_END_TYPE represents if the leader end has "Free End" or Attached End". The parameter TAG_LEADER_TYPE is now marked deprecated and may be removed in later versions of Revit:

The APIs that support cloud parameters have been replaced by new versions that support the input of the target region:

The IRevisionsOnSheetUIServer and RevisionsOnSheetUIServiceData classes, along with all of their members, have been marked as deprecated. These APIs were unintentionally exposed in Revit 2024. There are no Replacement member(s) APIs available for these classes or their members.

The following API members and classes which had previously been marked deprecated have been removed in this release. Consult the API documentation from prior releases for information on the Replacement member(s)s to use:

• Analysis.MassSurfaceData▾

• BuiltInFailures.RebarFailures.Inverted3dShape▾
• Mechanical.Zone.IsDefaultZone▾
• Mechanical.Zone.GrossArea▾
• Mechanical.Zone.Volume▾
• Mechanical.Zone.GrossVolume▾
• Mechanical.Zone.Perimeter▾

• Mechanical.ZoneServiceType

• Mechanical.Zone.CalculatedSupplyAirflow▾
• Mechanical.Zone.CalculatedHeatingLoad▾
• Mechanical.Zone.CalculatedCoolingLoad▾
• Mechanical.Zone.HeatingSetPoint▾
• Mechanical.Zone.CoolingSetPoint▾
• Mechanical.Zone.HeatingAirTemperature▾
• Mechanical.Zone.CoolingAirTemperature▾
• Mechanical.Zone.HumidificationSetPoint▾
• Mechanical.Zone.DehumidificationSetPoint▾

• Mechanical.Zone.Spaces

• ReinforcementSettings.NumberVaryingLengthRebarsIndividually▾
• ViewportPositioning▾

• Creation.Document.NewZone()▾
• Mechanical.Zone.AddSpaces▾
• Mechanical.Zone.RemoveSpaces▾
• StructuralConnectionHandlerType.AddElementsToCustomConnection()▾
• StructuralConnectionHandlerType.RemoveMainSubelementsFromCustomConnection()▾
• Rebar.CreateFromCurves(Document, RebarStyle, RebarBarType, RebarHookType, RebarHookType, Element, XYZ, IList<Curve>, RebarHookOrientation, RebarHookOrientation, double, double, ElementId, ElementId, bool, bool)▾
• Rebar.CreateFromCurves(Document, RebarStyle, RebarBarType, RebarHookType, RebarHookType, Element, XYZ, IList<Curve>, RebarHookOrientation, RebarHookOrientation, bool, bool)▾
• Rebar.CreateFromCurvesAndShape()▾
• Rebar.CreateFromCurvesAndShape()▾
• Rebar.RebarShapeMatchesCurvesAndHooks()▾
• Rebar.RebarShapeMatchesCurvesHooksAndEndTreatment()▾
• Rebar.GetHookOrientation()▾
• Rebar.SetHookOrientation()▾
• Rebar.SetHookRotationAngle()▾
• Rebar.CreateFreeForm()▾
• RebarContainer.AppendItemFromCurves()▾
• RebarContainer.AppendItemFromCurvesAndShape()▾
• RebarContainerItem.SetFromCurves()▾
• RebarContainerItem.SetFromCurvesAndShape()▾
• RebarContainerItem.SetHookOrientation()▾
• RebarContainerItem.GetHookOrientation()▾
• RebarFreeFormAccessor.GetHookOrientationAngle()▾
• RebarFreeFormAccessor.SetHookOrientationAngle()▾
• RebarFreeFormAccessor.GetHookOrientationAngleAtIndex()▾
• RebarFreeFormAccessor.GetHookPlaneNormalForBarIdx()▾
• RebarFreeFormAccessor.SetHookPlaneNormalForBarIdx()▾
• RebarFreeFormAccessor.CanBeHookNormal()▾
• RebarFreeFormAccessor.GetHookOrientationAtIndex()▾
• RebarShape.Create(Document, RebarShapeDefinition, RebarShapeMultiplanarDefinition, RebarStyle, StirrupTieAttachmentType, int, RebarHookOrientation, int, RebarHookOrientation, int)▾
• RebarShape.Create(Document, RebarShapeDefinition, RebarShapeMultiplanarDefinition, RebarStyle, StirrupTieAttachmentType, int, RebarHookOrientation, int, RebarHookOrientation, int, double, double, ElementId, ElementId)▾
• RebarShape.GetDefaultHookAngle()▾
• RebarShape.GetDefaultHookOrientation()▾
• RebarShape.GetEndTreatmentTypeId()▾
• RebarShape.GetHookRotationAngle()▾
• RebarShape.SetEndTreatmentTypeId()▾
• RebarShape.SetHookRotationAngle()▾
• RebarShape.IsSameShapeIgnoringHooks()▾
• RebarUpdateCurvesData.GetHookOrientationAngle()▾
• RebarUpdateCurvesData.SetHookOrientationAngle()▾
• RebarUpdateCurvesData.GetHookPlaneNormalForBarIdx()▾
• RebarUpdateCurvesData.SetHookPlaneNormalForBarIdx()▾
• RebarBendData.RebarBendData()▾
• RebarBendData.HookOrient0()▾
• RebarBendData.HookOrient1()▾
• ReinforcementSettings.NumberVaryingLengthRebarsIndividually()▾

• MassSurfaceDataMaterialType

• MassSurfaceDataSource

• RebarHookOrientation▾

• STAIRS_CURVE_TYPE

The new class:

• AnnotationLabel - Represents the label elements in annotation families. Labels are used to display parameter values as text.

The new property:

• UseNonBreakingSpaces - Represnts if non-breaking spaces should be used in the label text.

The new method:

• GetParameterFormatting() - Gets the collection of parameter formatting objects for the parameters seen in the label.

The new class:

• AnnotationLabelParameterFormatting - This

  is the annotation label parameter formatting settings for a parameter in an annotation label element.

The new properties:

• LeadingSpaces - The number of spaces to add before the parameter value.

• Prefix - The prefix to add before the parameter value.

• SampleText - The sample text to show in the label in the family environment.

• Suffix - The suffix to add after the parameter value.

• LeadingLineBreak - True if a leading line break should be added the leading spaces, prefix and parameter value.

The new method:

• GetParameterDefinition() - Represents the definition of the parameter shown in the label.

The new methods:

• Wall.SetHostWallId()

• Wall.GetHostWallId()

• Wall.CanSetHostWall()

provide access to the settings for the host assignment for specified wall. When a host wall is set, the specified wall will follow the host wall's movement or changes in slanted angle. For a wall to be considered valid for hosting, it must match the host wall in both orientation and span.

The new class:

• Autodesk.Revit.DB.Architecture.NumberSystemType

Defines parameters used in the Stair Tread/Riser Numbers annotation for Stair element

The new static method:

• Category.GetBuiltInCategoryDisciplines() - Allows users to get the ForgeTypeId identifier for each discipline for the given built-in category.

The new interface:

• Autodesk.Revit.CloudWorksharing.EditingPermissionService

provides API service that can be used for accessing permissions and relinquishing permissions on a given cloud model. This class is located in the Autodesk.Revit.CloudWorksharingAPI.Abstractions.dll assembly, and can be accessed via the new method:

• Autodesk.Revit.ApplicationServices.Application.GetExtendedApiService<TService>()

The EditingPermissionService offers methods:

• EditingPermissionService.GetUsersWithPermissionsAsync()

• EditingPermissionService.RelinquishUsersAsync()

to read and relinquish permission settings.

Added functionality that allows users to manage the Coordination Model links in Revit documents and set their visibility control in Revit views.

The new classes:

• ExternalData.CoordinationModelLinkOptions - Class containing link options for Coordination Models.

• ExternalData.CoordinationModelLinkData - Class containing link data for Coordination Model type element.

• ExternalData.CoordinationModelElementProperty - Defines the property of an element inside a Coordination Model.

• ExternalData.CoordinationModelLinkUtils - Utility class to support managing of Coordination Model links in Revit documents and their visibility settings control in Revit views.

The new enums:

• ExternalData.CoordinationModelLinkPathType - An enumerated type representing the options for the path type of a Coordination Model.

• ExternalData.CoordinationModelPositioning - An enumerated type listing possible placement modes for linking Coordination Models.

The new built-in parameters:

• ROTATE_TRUENORTH_ANGLE

• ROTATE_EASTWEST

These parameters are specific to True North / Shared Coordinates rotation.

This functionality enables access to properties created outside of Revit, allowing users and developers to view and consume information authored by domain experts who do not work directly within Revit.

The new class:

• ParameterAccess - Provides a common mechanism to access parameters, including extended properties.

The new classes in Autodesk.Revit.ExternalData namespace:

• ExtendedPropertiesLink - Represents a collection of extended properties linked to a Revit model.

• ExtendedParameterElement - An element that stores the definition of an extended property created by an extended properties link.

• ExtendedPropertiesLinkLoadContent - Represents the data needed to establish or update an ExtendedPropertiesLink.

  To be used as the result of invoking an external server in order to
  update or create an ExtendedPropertiesLink.

• ExtendedPropertiesLinkData - Represents the data needed to establish or update an ExtendedPropertiesLink.

  To be used as part of the result of invoking an external server in order to
  update or create an ExtendedPropertiesLink.

• ExtendedPropertiesBindings - Establishes the bindings for a given extended property.

  Supports the same style of binding as shared/project parameters - category and type vs instance.

• ExtendedPropertiesLinkValues - Holds information which can be converted to Revit parameter values.

• BuiltInFailures.ExtendedPropertiesLinkFailures - Extended properties link failures.

The new enum:

• ExtendedPropertiesBindingType - Enumeration type to indicate whether extended properties should be bound to instances or types. Visibility/Graphic Override API additions

The new methods require an additional new argument to specify the region of the Parameters Service account:

• ParameterUtils.DownloadParameter

• ParameterUtils.DownloadParameterOptions

• ParameterUtils.DownloadCompanyName

The new classes:

• Analysis.SizingOptions - Stores the sizing parameters such as the domain and profile types, the minimal and maximal available sizes, roughness, density and viscosity. The class may be constructed with a set of default values, or a specified duct or pipe curve element to extract the associated values.

• Analysis.SizingCalculator -

  Calculates the required duct or pipe size based on the specified parameters and constraints.

The new methods:

• SizingCalculator.CalculateSizeByFriction() - Takes the input of sizing parameters and calculates the size to satisfy the friction requirement. The result is stored in the SizingOptions if successful.

• SizingCalculator.CalculateSizeByVelocity() - Calculates the size to satisfy the velocity requirement.

• SizingCalculator.Friction() - Returns the friction of the specified flow and other parameters in the SizingOptions.

• SizingCalculator.Velocity() - Returns the velocity of the specified flow and sizing parameters.

• SizingCalculator.EquivalentDiameter() - Returns the equivalent diameter of the specified profile and sizes.

• SizingOptions.SetNextAvailableSize() - Sets the current size to the minimum available size that exceeds the threshold value.

• SizingOptions.SetEquivalentWidth() - Sets the current width with respect to the specified height so the equivalent diameter remains the same.

The MEPAnalyticalSegment class provides methods for accessing equivalent objects between MEPAnalyticalSegment and Subelement. The new methods:

• MEPAnalyticalSegment.GetSubelement() - Returns the Subelement of the analytical segment. The Subelement is a user pickable version of the analytical segment.

• MEPAnalyticalSegment.GetSegment(Subelement) - A static method that returns the MEPAnalyticalSegment object corresponding to the specified Subelement. The MEPAnalyticalSegment contains additional data and methods, enhancing the generic parameters of the Subelement.

The new enum value:

• gbXMLSpaceType.ServerRoom - Added a new enum value that corresponds to the spaceType attribute in gbXML.

The new properties:

• AnalyticalSpaceResolution - Represents the minimum gap between Revit elements that will be ignored in the identification of energy analytical model spaces.

• AnalyticalSurfaceResolution - Reperesents the smallest dimension of any surface to be included in the energy analytical model.

The new class:

• Autodesk.Revit.DB.Analysis.ViewHVACLoadsReport

provides functionality to run loads analysis on a Revit project. This process involves creating a new view instance, requesting the analysis, and checking its completion status.

MEP analytical segments can now expose additional descriptive information through the API, allowing downstream tools to preserve context or diagnostics when working with analytical models.

The new property:

• MEPAnalyticalSegment.Comments

provides access to descriptive or contextual text associated with an MEP analytical segment. The value can be assigned programmatically by calling SetComments with the corresponding AnalyticalModelData.

This release introduces a new framework for integrating custom external data types into Revit’s Manage Links dialog. The framework is centered on an external server that supplies rows for the Manage Links table and handles user commands such as add, remove, reload, or custom actions.

To participate in the Manage Links dialog for a custom external data type, developers implement an external server that provides data rows, commands, and command handling logic.

The new interface:

• Autodesk.Revit.UI.IExternalDataManagerServer

defines the contract for supplying data rows and commands for a custom external data type displayed in the Manage Links dialog.

Key methods on this interface include:

• IExternalDataManagerServer.GetTitle()

• IExternalDataManagerServer.GetData()

• IExternalDataManagerServer.OnCommand()

• IExternalDataManagerServer.IsCommandEnabled()

Other methods optionally support preview images and availability in family documents, but the primary integration pattern is to supply data items, define commands, and handle command execution.

Commands for a custom external data type are defined and registered independently, then surfaced by the server to the Manage Links UI.

The new class:

• Autodesk.Revit.UI.ExternalDataManagerCommand

represents a command that can be shown in the Add menu or as a content tool for selected rows.

The primary command registration method:

• ExternalDataManagerCommand.RegisterCommand()

registers a command with its identifier, localized display name, tooltip, and behavior flags.

Commands to add new instances of the external data item are surfaced to the UI by the server through:

• IExternalDataManagerServer.GetCommandsForAdd()

while other commands are provided by:

• IExternalDataManagerServer.GetContentTools()

which supports the addition of tool items and optional submenus associated with the currently selected rows.

Command execution is handled centrally via:

• IExternalDataManagerServer.OnCommand()

allowing the server to respond to both Add commands and row-based content tools.

Each row shown in the Manage Links dialog for a custom external data type is represented by an ExternalDataManagerDataItem. Instances of this class are created and returned by IExternalDataManagerServer.GetData().

The new class:

• Autodesk.Revit.UI.ExternalDataManagerDataItem

represents a single Manage Links row for an external data reference.

Key properties on ExternalDataManagerDataItem include:

• Id

• Name

• Status

• ReferenceType

• Size

• Resolution

• Path

• PathType

• Count

• Version

Each item is uniquely identified by an ExternalDataManagerDataItemId, which provides a stable identifier for command execution and selection tracking.

The External Data Manager framework also supports preview image integration and checks for availability in family documents.

The new classes:

• Autodesk.Revit.DB.FabricationPartInsulationLining - Represent the insulation or lining element of fabrication partm, similar to the insulation and lining element (e.g., DuctInsulation, DuctLining, or PipeInsulation) of design elements.

• Autodesk.Revit.DB.FabricationOptionDefinition - Represents a single fabrication pattern option definition.

The new methods:

• FabricationPartInsulationLining.GetOwnerId() - Returns the element Id of owner part.

• FabricationPart.GetInsulationLiningElementId() - Returns the insulation or lining element Id of part.

• FabricationPart.GetOptionDefinitions() -Returns a list of available FabricationOptionDefinition.

• FabricationPart.GetSeamCount and FabricationPart.GetSeamInfo() - Returns the part seam id in the fabrication database. The API users can acquire the seam name and a complete list via the methods FabricationConfiguration.GetSeamName() and FabricationConfiguration.GetAllSeamIds().

• FabricationPart.GetAirturnCount and FabricationPart.GetAirturnInfo - Returns the duct air turn id in the fabrication database. The API users can acquire the air turn name and a complete list via the methods FabricationConfiguration.GetAirturnName() and FabricationConfiguration.GetAllAirturnIds()

• FabricationPart.GetStiffenerCount and FabricationPart.GetStiffenerInfo() - Returns the duct stiffener id in the fabrication database. The API users can acquire the duct stiffener name and a complete list via the methods FabricationConfiguration.GetStiffenerName() and FabricationConfiguration.GetAllStiffenerIds().

• FabricationPart.GetOptionValue()

• FabricationPart.SetOptionValue()

The new properties:

• FabricationPart.HandlePosition - Get or Set the part handle position if the part property "HasHandle" is true.

• FabricationOptionDefinition.Name - Represents Fabrication option name.

• FabricationOptionDefinition.IsModifiable - Checks if the fabrication option is modifiable by user.

The new method:

• Surface.isCoincidentWith() - Determines whether two surfaces are coincident, ignoring any envelopes. To return true, the surfaces must be of the same type (e.g., two planes, two spheres, etc.).

The new class:

• IFCOpeningDimensions - A class that contains calculated dimensions for an IFC opening.

The new method:

• ExporterIFCUtils.SortFaceEdges - Sorts the edges of a face such that the outer edge loops and their corresponding inner edge loops are separated.

The new property:

• RevitLinkGraphicsSettings.LineWeights - Controls whether the line weights for links in the view should be by host model or by link. It can be set to either LinkVisibility.ByLinkView or LinkVisibility.ByHostView, similar to other properties in this class. This property is separate from ObjectStyles which control pen number selections. For the same pen number the LineWeights property can be used to decide if the pen number should use the Line Weight table from the link model or the host model.

The newly enhanced numbering system in Revit offers flexibility and customization beyond what was previously available. Originally limited to elements such as Reinforcement (Rebar, Fabric, Area, Path), and Couplers, the numbering system now extends to any element within Revit. This enhancement significantly improves workflows and project organization. The versatile numbering schemas allow users to create multiple numbering schemas for different project needs. Numbered elements can be filtered based on view filters, allowing for specific organization and control. The output number can be any string-type parameter that is writable and present on all elements filtered by the view. Elements can be matched by their own parameters, the parameters of associated elements (e.g., doors accessing room parameters), or by their geometry. Additionally, elements can be partitioned based on their parameters or the parameters of associated elements. The flexible number formatting capability allows output numbers to include digits, letters, parameter values, or additional text, similar to the tag system in Revit.

The new classes:

• Autodesk.Revit.DB.NumberingParameterType - Defines parameters used in the numbering system, including relation information such as to/from room, structural material, etc.

• NumberingSequenceInfo - Contains information regarding a numbering sequence for UI use.

• Autodesk.Revit.DB.NumberingParameter - Contains an ElementId for a parameter and a NumberingParameterType.

• Autodesk.Revit.DB.NumberingFormattedParameter - Settings related to formatting a single parameter in the final number, including prefix, suffix, and separator.

• Autodesk.Revit.DB.NumberingFormatSettings - A collection of NumberingFormatSettings plus additional information for generating the final output, such as letter vs. number usage and minimum number of digits.

• Autodesk.Revit.DB.NumberedReferenceInfo - Generated via Autodesk.Revit.DB.NumberingSchema.GetReferencesInfos. Returns all numbering info for a set of references and a document.

The new enum:

• FirstNumberFormattingOptions - Defines the formatting options for the start of a sequence.

The new methods in Autodesk.Revit.DB.NumberingSchema:

• GetAvailableParameters() - Gets the list of built-in parameters that can be used in matching, partitioning and formatting in the numbering system.

• GetValidCategoriesForNumbering() - Gets the list of categories that can be numbered by the system.

• GetSchemasInDocument() - Gets a set of all the numbering schemas from a document.

• GetNumberOfPartitions() - Gets the number of partitions managed by the schema.

• GetNumberingInfoForReferences() - Gets information for a set of references regarding the numbers they have, the partition where they reside and the numbering schemas that handle them.

• GetNumberingSchema() - Gets an instance of a numbering schema based on it's name. Names for numbering schemas are unique per document.

• GetMatchingParameters() - Gets the parameters used by a specific numbering schema in matching elements so they would get the same number.

• SetMatchingParameters() - Sets the parameters used by a specific numbering schema for matching elements so they would get the same number.

• AddMatchingParameter() - Add one parameter to the set of parameters used to match elements so they would get the same number.

• RemoveMatchingParameter() - Remove a parameter from the set of parameters used in matching elements so they would get the same number.

• SetUseBuiltInMatchingForCategories() - Use the built-in matching criteria for a set of categories if one is available for a given category.

• GetUseBuiltInMatchingForCategories() - Get the set of categories where the built-in matching criteria is used.

• GetPartitioningParameters() - Get the set of parameters used by this numbering schema to segregate a set of elements to a separate set of element where matching and numbering will be performed.

• SetPartitioningParameters() - Set the set of parameters used by this numbering schema to segregate a set of elements to a separate set of element where matching and numbering will be performed.

• AddPartitioningParameter() - Add a parameter to the partitioning set.

• RemovePartitioningParameter() - Remove a parameter from the partitioning set.

• GetNumberingSequencesInfos() - Returns information on the data in all all the numbering sequences within this numbering schema.

• SwapNumber() - Replaces an existing number with a another one that exists in the same partition.

• CanChangePartitioningValue() - Partitioning is done only based on a single parameter and it's value is not read-only.

• ChangePartitioningValue() - Set the partitioning parameter for all the elements in a partition.

• CanChangePartitioningValue() - Predicate used to determine if the partition is based on one element and that element is of string type and editable on all the numbered elements for this schema.

• GetFormatting() - Get an object of type NumberingFormatSettings that determines everything related to generating the final number stored in the NumberingParameterId for the elements managed by this schema.

• SetFormatting() - Sets the NumberingFormatSettings for this schema.

• Create() - Create a new numbering schema. The numbering is done on a set of elements determined by a filter using a specific parameter that exists on all this elements as the output.

• GetScopeDefiningCategories() - Get all the categories for the elements that are going to be numbered by this schema.

• SetScopeDefiningFilterAndOutputParam() - Sets the filter and the output parameter that is going to be used by this schema.

• HasRoomRelatedParameters - True if the schema has in it's matching, it's formatting or it's partitioning associated parameters related to "to/from room"

• ApplyExternalSorting() - Applies an externally defined sort order to elements in a partition by assigning specific numbers.

The new properties in Autodesk.Revit.DB.NumberingSchema:

• Enabled - True if the schema is enabled and affects the document.

• Priority - A value that determines what schema is executed if two schemas affect the same categories and have the same output parameter.

• MatchGeometry - If true elements with the same geometry will be assigned the same number if they exist in the same partition.

• NumberingParameterId - The output parameter where the numbering schema generate the final number can now also be set.

• ScopeDefiningFilter - Gets or sets a filter that will be used to determine the elements that this schema will number.

This release introduces new APIs for representing and associating embodied carbon data with materials, enabling sustainability-focused analysis workflows directly within the Revit data model.

A new asset type has been introduced to capture embodied carbon information associated with materials.

The new class:

• Autodesk.Revit.DB.EmbodiedCarbonAsset

represents the embodied carbon–related properties of a material, including carbon coefficient values, units, and provider metadata used for sustainability calculations.

An embodied carbon asset stores both user-visible and internal identifiers for the data provider and category, along with the carbon coefficient value and its associated unit type.

To support unit consistency, embodied carbon coefficients are expressed using an enum that identifies how the coefficient should be interpreted (for example per length, area, volume, mass, or item). This enum is consumed through the EmbodiedCarbonAsset.CarbonCoefficientUnitType property rather than being used directly in isolation.

Embodied carbon assets are stored in the document using property set elements, allowing them to be referenced and reused consistently.

The new overload:

• PropertySetElement.Create(Document, EmbodiedCarbonAsset)

provides the primary mechanism for persisting embodied carbon data within a Revit project.

The new property:

• Material.EmbodiedCarbonAssetId

gets or sets the ElementId of the PropertySetElement that contains the embodied carbon asset associated with the material.

Together, these APIs enable developers to attach embodied carbon information to materials and retrieve it later for analysis, reporting, or export workflows.

The new method:

• Material.GetIdentityParameterIds()

returns the ids of the parameter identifiers used by the “Identity” section of a Material element.

The new method:

• ParameterUtils.WriteSharedParametersToFile() - Generates a shared parameters text file from the shared parameters in a given document. Only shared parameters that are used in the project are written to the output.

IndependentTag and SpatialElementTag now allow the leader start point to be either attached to the tag head or freely positioned, enabling more precise layout and annotation workflows.

Tags now expose an explicit property that controls how the leader start point behaves.

The new properties:

• IndependentTag.LeaderStartCondition

• SpatialElementTag.LeaderStartCondition

control whether the leader start point is attached to the tag head or can be freely positioned.

The leader start condition is specified using an enum that defines the supported behaviors, including the default attached behavior and an optional free-start mode that allows manual positioning.

When a tag supports a free leader start condition, new APIs allow callers to query and modify the leader’s starting position.

The new methods:

• IndependentTag.GetLeaderStart()

• SpatialElementTag.GetLeaderStart()

return the current starting position of the leader. The leader start point is defined as the point on the leader line closest to the tag head.

The new methods:

• IndependentTag.SetLeaderStart()

• SpatialElementTag.SetLeaderStart()

sets the starting position of a free-start leader.

Before assigning a leader start condition, compatibility can be checked using:

• IndependentTag.CanLeaderStartConditionBeAssigned()

which determines whether a given tag supports a specific leader start condition. For example, not all tag types support free-start leaders.

The Revit API now exposes the classes PropertyLine and PropertyTableEntry with a full set of methods and properties, enabling third-party developers to convert supported elements into native Revit components.

The new classes:

• PropertyLine - Represents the property line element

• PropertyTableEntry - The class is used to store the property table row data

The new methods:

• PropertyLine.Create(Document document, IList<CurveLoop>)

• PropertyLine.Create(Document document, IList<PropertyTableEntry>)

• PropertyLine.IsValidBoundary()

• PropertyLine.IsValidPropertyTable()

• PropertyLine.ConvertToTable()

• PropertyLine.GetStart()

• PropertyLine.SetStart()

• PropertyLine.SetBoundary()

• PropertyLine.GetBoundary()

• PropertyLine.SetPropertyTable()

• PropertyLine.GetPropertyTable()

• PropertyTableEntry.Create()

• PropertyTableEntry.IsValidPropertyTableEntry()

The new properties:

• PropertyLine.Area - Represents the area of the PropertyLine element, if it is close loop, the value would be greater than 0, otherwise it will return -1.

• PropertyTableEntry.Distance - Represents the distance value of the PropertyTableEntry

• PropertyTableEntry.Bearing - Represents the bearing angle value of the PropertyTableEntry

• PropertyTableEntry.Id - Unique identifier for this PropertyTableEntry

• PropertyTableEntry.ArcDirection - Represent the arc direction, PT_Left means the arc appears to the left of the line segment. PT_Right means the arc appears to the right of the line segment.

• PropertyTableEntry.Radius - Represents the radius for arc type curve. The radius value must be greater than half the length of the line segment. The larger the radius, the larger the circle becomes, resulting in a flatter arc.

The new enum:

• PropertyTableEntry.PropertyTableEntryCurveType - An enumerated type that represents the curve types supported in a table entry for a PropertyLine element.

• PropertyTableEntry.PropertyTableEntryArcDirection - An enumerated type that represents the arc directions supported in an Arc table entry for a PropertyLine element.

This release expands the Structure API to support programmatic creation and modification of boundary conditions for structural analysis. Developers can now create point, line, and area boundary conditions directly in a project, either as custom geometry or hosted on existing elements, with detailed control over translational and rotational constraints.

New factory methods enable boundary conditions to be created for different geometric representations and hosting scenarios.

The new methods:

• BoundaryConditions.CreatePointBoundaryConditions()

• BoundaryConditions.CreateLineBoundaryConditions()

• BoundaryConditions.CreateAreaBoundaryConditions()

support both hosted and non-hosted workflows. Hosted variants accept a reference to an existing element, while custom variants allow boundary conditions to be defined using explicit geometry such as points, curves, or curve loops. These methods allow specification of translational and rotational constraint behavior, including spring modulus values for each degree of freedom.

New APIs support updating existing boundary conditions after creation, enabling more flexible editing workflows.

The new methods:

• BoundaryConditions.SetCurve()

• BoundaryConditions.SetLoops()

• BoundaryConditions.RemoveHostConstraint()

allow line and area boundary condition geometry to be updated and enable hosted boundary conditions to be detached from their hosts when required.

Additional properties expose boundary condition state and configuration, allowing inspection and downstream processing.

The new properties:

• BoundaryConditions.SketchId

• BoundaryConditions.Point

• BoundaryConditions.IsConstrainedOnHost

• BoundaryConditions.BoundaryConditionsPreset

With the three new types of boundary conditions, there are new subcategories associated to each:

• OST_PointBoundaryConditions

• OST_LineBoundaryConditions

• OST_AreaBoundaryConditions

the existing boundary condition category, OST_BoundaryConditions, remains in place for backward compatibility but should be deprecated in favor of the new sub-categories. All related code should be updated to utilize these new categories.

The new property:

• SketchId

  - Represents the sketch associated to this Revit element.

New classes and corresponding enumerated values have been added to represent new types of concrete structural sections (that can be accessed from, for example, StructuralSectionUtils.GetStructuralElementDefinitionData()):

• Autodesk.Revit.DB.Structure.StructuralSections.StructuralSectionConcreteI

• Autodesk.Revit.DB.Structure.StructuralSections.StructuralSectionConcreteL

• Autodesk.Revit.DB.Structure.StructuralSections.StructuralSectionConcretePolygon

The new enum value:

• AnalyticalStructuralRole.StructuralRoleCladding - This new value will be displayed when setting Analytical Panel Structural Role parameter in MPP.

This release introduces significant enhancements to the Rebar API, with a focus on expanded support for free form rebar distribution, custom spacing formulas, and more flexible constraint targeting. These changes enable more advanced rebar modeling workflows and improved control over constraint behavior.

Free form rebar workflows have been expanded to support 3D path and morphed distributions, with additional control over how rebar sets are oriented and manipulated.

A new data container has been introduced to encapsulate the geometry and termination information required to compute free form rebar sets distributed along a 3D path.

The new class:

• ComputationDataFor3DPathSet

Encapsulates the data required to compute a 3D path free form rebar set and serves as the primary input for 3D path–based free form rebar computation.

Key creation and access methods include:

• ComputationDataFor3DPathSet.CreateFromCurves()

• ComputationDataFor3DPathSet.CreateFromRebar()

• ComputationDataFor3DPathSet.GetCurves()

Additional properties and methods on this class allow callers to control termination orientation and out-of-plane rotation at the start and end of the bar, as well as to query or set the termination plane normal used for hooks or cranks.

The Rebar API now supports custom spacing formulas that allow variable spacing between bars within a set.

A new layout rule supports this behavior and is accessed through methods on the Rebar and rebar accessor APIs rather than through direct enum manipulation.

Key methods on the Rebar class include:

• Rebar.SetLayoutFormula()

• Rebar.GetLayoutFormula()

• Rebar.IsValidCustomSpacingFormula()

• Rebar.ComputeSpacingsBetweenBars()

• Rebar.GetSpacingsBetweenBars()

• Rebar.IsCustomSpacingWithPredefinedNumberOfBars()

These APIs allow clients to define, validate, and evaluate custom spacing formulas, as well as to query the resolved spacings applied to a rebar set.

The constraint system has been extended to support additional target types, including host edges, host edges' cover, custom targets, and edges of other rebar elements.

These new constraint modes enable more precise positioning of rebar handles relative to structural geometry and other reinforcement elements. Support for each constraint type can be queried at runtime through handle-level APIs.

The RebarConstrainedHandle API now exposes richer introspection capabilities, allowing clients to determine how a given handle can be constrained and manipulated during editing.

The primary entry point for interacting with constraints on a handle is:

• Rebar.GetRebarConstraintsManager()

which returns the RebarConstraintsManager responsible for managing constraints associated with that handle. In addition, the new method:

• RebarConstrainedHandle.GetRebarConstraintsManager()

is provided for convenience to access the RebarConstraintsManager directly from a RebarConstrainedHandle.

To support interactive and programmatic workflows, several new query methods allow callers to determine what constraint types and behaviors are supported by a specific handle, including:

• RebarConstrainedHandle.IsDraggable()

• RebarConstrainedHandle.AllowsConstraintToHostEdge()

• RebarConstrainedHandle.AllowsConstraintToHostEdgeCover()

• RebarConstrainedHandle.AllowsConstraintToSurface()

• RebarConstrainedHandle.AllowsConstraintToOtherRebarEdge()

• RebarConstrainedHandle.AllowsConstraintToCustomTarget()

• RebarConstrainedHandle.AllowsDistanceToHostEdgeOrHostEdgeCover()

In addition, handle position can be queried in a given view using:

• RebarConstrainedHandle.GetHandlePosition()

Together, these APIs allow clients to adapt behavior dynamically based on the capabilities of the selected handle.

New factory methods and validation helpers on the RebarConstraint class support creating and managing constraints for the newly introduced target types.

Key constraint creation entry points include:

• RebarConstraint.CreateConstraintToHostEdge()

• RebarConstraint.CreateConstraintToHostEdgeCover()

• RebarConstraint.CreateConstraintToCustomTarget()

• RebarConstraint.CreateConstraintToRebarEdge()

Once created, constraints can be queried and updated using methods that expose target geometry and distances, such as retrieving the target host edge and transform, querying or setting distances to host edges, covers, or custom targets, and checking the active constraint type.

Validation responsibilities have been clarified and split by target type. New validation methods allow callers to determine whether a given reference is suitable for face-based or edge-based constraints before attempting constraint creation.

Additional properties expose whether constraint targets or layout definitions were affected during regeneration, enabling clients to respond to structural changes or invalidated assumptions.

The new properties:

• RebarUpdateCurvesData.StartConstraintLostTargets

• RebarUpdateCurvesData.EndConstraintLostTargets

• RebarUpdateCurvesData.IsCustomSpacingFormulaChanged

indicate whether constraints lost one or more targets or whether a custom spacing formula has changed since the previous regeneration.

The RebarFreeFormAccessor API has been expanded to provide higher-level access to free form rebar configuration and state.

The new methods for configuring and querying free form rebar include:

• RebarFreeFormAccessor.SetLayoutAsCustomSpacing()

• RebarFreeFormAccessor.HasValidSurfaceServer()

• RebarFreeFormAccessor.HasValid3DPathServer()

• RebarFreeFormAccessor.HasValidMorphedServer()

For 3D path based distributions, computation data can be set or retrieved using:

• RebarFreeFormAccessor.SetComputationDataFor3DPathSet()

• RebarFreeFormAccessor.GetComputationDataFor3DPathSet()

Additional helper methods support validating morphed rebar targets, determining default positive directions for target edges, and flipping the distribution path for 3D path–based sets.

The new method:

• Rebar.SplitRebar()

allows users to splits a rebar into multiple sets at specified bar indices.

The new properties:

• Rebar.Mass

• RebarInSystem.Mass

returns the mass of the rebar set. It is computed as the sum of the masses of all individual bars.

The new properties:

• BarTypeDiameterOptions.BarMassPerUnitLength

• RebarBarType.BarMassPerUnitLength

provide access to the bar mass per unit length.

The new class:

• Mechanical.HVACZoneData - Represents the specific domain requirements for a system-zone upgraded from an HVAC zone.

The new properties:

• Mechanical.SystemZoneElementType.HeatingAirTemperature - Represents the heating air temperature in unit Kelvin (K).

• Mechanical.SystemZoneElementType.CoolingAirTemperature - Represents the cooling air temperature in unit Kelvin (K).

The new method:

• DockablePane.SetTitle()

allows applications to set the title (a.k.a. window caption) of the dockable pane.

The new property:

• ProjectBrowserOptions.AutoExpandSheetViewsOnViewPlacement

accesses the option for whether sheet views automatically expand when placing a view on them in the Project Browser.

The Application class now exposes properties that allow API clients to query and control whether specific structural disciplines are enabled.

The new properties:

• Application.IsConcreteEnabled

• Application.IsPrecastEnabled

allow callers to determine whether concrete and precast functionality is available and to enable or disable those disciplines programmatically.