64 min read

Source: Roblox Creator Hub · CC BY 4.0 · View source · Code samples: MIT Imported 2026-10-03. Formatting adapted for this site.

BasePart

Inherits from: PVInstance → Instance → Object

BasePart is an abstract base class for in-world objects that render and are physically simulated while in the Workspace. There are several implementations of BasePart, the most common being Part and MeshPart. Others include WedgePart, SpawnLocation, and the singleton Terrain object. Generally, when documentation refers to a "part," most BasePart implementations will work and not just Part.

For information on how BaseParts are grouped into simulated rigid bodies, see Assemblies.

There are many different objects that interact with BasePart (other than Terrain), including:

• Several BaseParts may be grouped within a Model and moved at the same time using PVInstance:PivotTo(). See Models.
• A Decal applies a stretched image texture to the faces of a BasePart, while a Texture applies a tiled image texture to the faces. See Textures and Decals.
• A SurfaceGui renders GuiObjects on the face of a part. See In-Experience UI Containers.
• Attachments can be added to a BasePart to specify CFrames relative to the part. These are often used by physical Constraint objects as outlined in Mechanical Constraints and Mover Constraints.
• ParticleEmitter objects emit particles uniformly in the volume of the BasePart to which they are parented. See Particle Emitters.
• Light objects like PointLight emit light from the center of a BasePart as illustrated in Light Sources.
• If parented to a Tool and given the name Handle, a BasePart can be held by characters. See In-Experience Tools.

Inherits from: PVInstance

Descendants: Terrain, CornerWedgePart, FormFactorPart, TriangleMeshPart, TrussPart, VehicleSeat

Memory category: Instances

Tags: NotCreatable, NotBrowsable

Code samples: View on Creator Hub (SmoothDamp-CFrame).

Properties

Inherited from PVInstance

Inherited from Instance

Inherited from Object

BasePart.Anchored

The Anchored property determines whether the part will be immovable by physics. When enabled, a part will never change position due to gravity, other part collisions, overlapping other parts, or any other physics-related causes. As a result, two anchored parts will never fire the Touched event on each other.

An anchored part may still be moved by changing its CFrame or Position, and it still may have a nonzero AssemblyLinearVelocity and AssemblyAngularVelocity.

Finally, if an unanchored part is joined with an anchored part through an object like a Weld, it too will act anchored. If such a joint breaks, the part may be affected by physics again. See Assemblies for more details.

Network ownership cannot be set on anchored parts. If a part's anchored status changes on the server, the network ownership of that part will be affected.

Code samples: View on Creator Hub (Part-Anchored-Toggle).

BasePart.AssemblyAngularVelocity

The angular velocity vector of this part's assembly. It's the rate of change of orientation in radians per second.

Angular velocity is the same at every point of the assembly.

Setting the velocity directly may lead to unrealistic motion. Using Torque or AngularVelocity constraint is preferred, or use ApplyAngularImpulse() if you want instantaneous change in velocity.

If the part is owned by the server, this property must be changed from a server Script (not from a LocalScript or a Script with RunContext set to RunContext.Client). If the part is owned by a client through automatic ownership, this property can be changed from either a client script or a server script; changing it from a client script for a server-owned part will have no effect.

BasePart.AssemblyCenterOfMass

A position calculated via the Mass and Position of all the parts in the assembly.

If the assembly has an anchored part, that part's center of mass will be the assembly's center of mass, and the assembly will have infinite mass.

Knowing the center of mass can help the assembly maintain stability. A force applied to the center of mass will not cause angular acceleration, only linear. An assembly with a low center of mass will have a better time staying upright under the effect of gravity.

BasePart.AssemblyLinearVelocity

The linear velocity vector of this part's assembly. It's the rate of change in position of AssemblyCenterOfMass in studs per second.

If you want to know the velocity at a point other than the assembly's center of mass, use GetVelocityAtPosition().

Setting the velocity directly may lead to unrealistic motion. Using a VectorForce constraint is preferred, or use ApplyImpulse() if you want instantaneous change in velocity.

If the part is owned by the server, this property must be changed from a server Script (not from a LocalScript or a Script with RunContext set to RunContext.Client). If the part is owned by a client through automatic ownership, this property can be changed from either a client script or a server script; changing it from a client script for a server-owned part will have no effect.

BasePart.AssemblyMass

The sum of the mass of all the BaseParts in this part's assembly. Parts that are Massless and are not the assembly's root part will not contribute to the AssemblyMass.

If the assembly has an anchored part, the assembly's mass is considered infinite. Constraints and other physical interactions between unanchored assemblies with a large difference in mass may cause instabilities.

BasePart.AssemblyRootPart

This property indicates the BasePart automatically chosen to represent the assembly's root part. If the part is not parented to the Workspace, this property will be nil.

The root part can be changed by changing the RootPriority of the parts in the assembly.

Parts that all share the same AssemblyRootPart are in the same assembly.

For more information on root parts, see Assemblies.

BasePart.AudioCanCollide

AudioCanCollide determines whether the part will physically interact with audio simulation, similar to CastShadow for lighting.

When disabled, audio passes through the part; it is not occluded or reflected.

BasePart.BackParamA

Deprecated.

The BackParamA property is relevant when a part's BasePart.BackSurface is set to Motor or SteppingMotor and BasePart.BackSurfaceInput is set to Sin. It determines the amplitude of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.BackParamB

Deprecated.

The BackParamB property is relevant when a part's BasePart.BackSurface is set to Motor or SteppingMotor and BasePart.BackSurfaceInput is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the frequency of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.BackSurface

The BackSurface property determines the type of surface used for the positive Z direction of a part. When two parts' faces are placed next to each other, they may create a joint between them.

BasePart.BackSurfaceInput

Deprecated.

The BackSurfaceInput property determines the kind of input provided to a part's BasePart.BackSurface. This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how BasePart.BackParamA and BasePart.BackParamB are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.

• By default, this is set to NoInput. This stops the motor altogether.
• For Constant, the motor rotates at a constant velocity equal to ParamB.
• For Sin, the motor rotates at a velocity equal to ParamA * math.sin(workspace.DistributedGameTime * ParamB). See Workspace.DistributedGameTime.

Code samples: View on Creator Hub (Motor-Control).

BasePart.BottomParamA

Deprecated.

The BottomParamA property is relevant when a part's BasePart.BottomSurface is set to Motor or SteppingMotor and BasePart.BottomSurfaceInput is set to Sin. It determines the amplitude of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.BottomParamB

Deprecated.

The BottomParamB property is relevant when a part's BasePart.BottomSurface is set to Motor or SteppingMotor and BasePart.BottomSurfaceInput is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the frequency of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.BottomSurface

The BottomSurface property determines the type of surface used for the negative Y direction of a part. When two parts' faces are placed next to each other, they may create a joint between them.

BasePart.BottomSurfaceInput

Deprecated.

The BottomSurfaceInput property determines the kind of input provided to a part's BasePart.BottomSurface. This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how BasePart.BottomParamA and BasePart.BottomParamB are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.

• By default, this is set to NoInput. This stops the motor altogether.
• For Constant, the motor rotates at a constant velocity equal to ParamB.
• For Sin, the motor rotates at a velocity equal to ParamA * math.sin(workspace.DistributedGameTime * ParamB). See Workspace.DistributedGameTime.

Code samples: View on Creator Hub (Motor-Control).

BasePart.BrickColor

This property determines the color of a part. If the part has a Material, this also determines the color used when rendering the material texture. For more control over the color, the Color property can be used and this property will use the closest BrickColor.

Other visual properties of a part are determined by Transparency and Reflectance.

BasePart.brickColor

Deprecated. This deprecated property is an old Camel Case variant of the Pascal Case BasePart.BrickColor, which should be used instead.

BasePart.CanCollide

CanCollide determines whether a part will physically interact with other parts. When disabled, other parts can pass through the part uninterrupted. Parts used for decoration usually have CanCollide disabled, as they need not be considered by the physics engine.

If a part is not Anchored and has CanCollide disabled, it may fall out of the world to be eventually destroyed by Workspace.FallenPartsDestroyHeight.

When CanCollide is disabled, parts may still fire the Touched event (as well the other parts touching them). You can disable this with CanTouch.

For more information on collisions, see Collisions.

Code samples: View on Creator Hub (Fade-Door).

BasePart.CanQuery

This property determines whether the part is considered during spatial query operations, such as GetPartBoundsInBox or Raycast. Note that CanCollide must be disabled for CanQuery to take effect, and spatial query functions will never include parts with CanQuery of false.

Beyond this property, it is also possible to exclude parts which are descendants of a given list of parts using an OverlapParams or RaycastParams object when calling the spatial query functions.

BasePart.CanTouch

This property determines if Touched and TouchEnded events fire on the part. If true, other touching parts must also have CanTouch set to true for touch events to fire. If false, touch events cannot be set up for the part and attempting to do so will throw an error. Similarly, if the property is set to false after a touch event is connected, the event will be disconnected and the TouchTransmitter removed.

Note that this collision logic can be set to respect collision groups through the Workspace.TouchesUseCollisionGroups property. If true, parts in non-colliding groups will ignore both collisions and touch events, thereby making this property irrelevant.

Performance

There is a small performance gain on parts that have both CanTouch and CanCollide set to false, as these parts will never need to compute any kind of part to part collisions. However, they can still be hit by Raycasts and OverlapParams queries.

BasePart.CastShadow

Determines whether or not a part casts a shadow. Disabling this property for a given part can cause visual artifacts on the shadows cast upon that part.

This property is not designed for performance enhancement, but in complex scenes, strategically disabling it on certain parts can improve performance. Due to the possibility of visual artifacts, we recommend leaving it enabled on all parts in most situations.

BasePart.CenterOfMass

The CenterOfMass property describes the local position of a part's center of mass. If this is a single part assembly, this is the AssemblyCenterOfMass converted from world space to local. On simple Parts, the center of mass is always (0, 0, 0), but it can vary for WedgePart or MeshPart.

BasePart.CFrame

The CFrame property determines both the position and orientation of the BasePart in the world. It acts as an arbitrary reference location on the geometry, but ExtentsCFrame represents the actual CFrame of its physical center.

When setting CFrame on a part, other joined parts are also moved relative to the part, but it is recommended that you use PVInstance:PivotTo() to move an entire model, such as when teleporting a player's character.

Unlike setting BasePart.Position, setting CFrame will always move the part to the exact given CFrame; in other words: no overlap checking is done and the physics solver will attempt to resolve any overlap unless both parts are Anchored.

For keeping track of positions relative to a part's CFrame, an Attachment may be useful.

Code samples: View on Creator Hub (Setting-Part-CFrame).

BasePart.CollisionGroup

The CollisionGroup property describes the name of the part's collision group (maximum of 100 characters). Parts start off in the default group whose name is "Default". This value cannot be empty.

Although this property itself is non-replicated, the engine internally replicates the value through another private property to solve backward compatibility issues.

Code samples: View on Creator Hub (WorldRoot-RegisterCollisionGroup).

BasePart.CollisionGroupId

Deprecated.

The BasePart.CollisionGroupId property describes the ID number of the part's collision group. Parts start off in the "Default" group whose ID is 0. If a part is unregistered, the value becomes -1. This value cannot be less than -1 and it cannot exceed WorldRoot:GetMaxCollisionGroups(). Invalid IDs are clamped.

Although this property can be directly changed, it's recommended that you specify the collision group by setting BasePart.CollisionGroup to the collision group's name.

BasePart.Color

The Color property determines the color of a part. If the part has a Material, this also determines the color used when rendering the material texture.

If this property is set, BrickColor will use the closest match to this Color value.

Other visual properties of a part are determined by Transparency and Reflectance.

Code samples: View on Creator Hub (Character-Health-Body-Color).

BasePart.CurrentPhysicalProperties

CurrentPhysicalProperties indicates the current physical properties of the part. You can set custom values for the physical properties per part, custom material, and material override. The Roblox engine prioritizes more granular definitions when determining the effective physical properties of a part. The values in the following list are in order from highest to lowest priority:

• Custom physical properties of the part
• Custom physical properties of the part's custom material
• Custom physical properties of the material override of the part's material
• Default physical properties of the part's material

BasePart.CustomPhysicalProperties

CustomPhysicalProperties lets you customize various physical aspects of a part, such as its density, friction, and elasticity.

If enabled, this property let's you configure these physical properties. If disabled, these physical properties are determined by the Material of the part.

Code samples: View on Creator Hub (Set-CustomPhysicalProperties).

BasePart.Elasticity

Deprecated. This is only one of multiple physics-related properties. It has been deprecated in favor of BasePart.CustomPhysicalProperties, which combines these properties into one.

The Elasticity of a part is now determined by either its Material or its CustomPhysicalProperties.

BasePart.EnableFluidForces

When true, and when Workspace.FluidForces is enabled, causes the physics engine to compute aerodynamic forces on this BasePart.

BasePart.ExtentsCFrame

The CFrame of the physical extents of the BasePart, representing its physical center.

BasePart.ExtentsSize

The actual physical size of the BasePart as regarded by the physics engine, for example in collision detection.

BasePart.Friction

Deprecated. This is only one of multiple physics-related properties. It has been deprecated in favor of BasePart.CustomPhysicalProperties, which combines these properties into one.

Used to control the Friction of the part, but now it no longer does anything. The Friction of a part is now determined by either its Material or its CustomPhysicalProperties.

BasePart.FrontParamA

Deprecated.

The FrontParamA property is relevant when a part's BasePart.FrontSurface is set to Motor or SteppingMotor and BasePart.FrontSurfaceInput is set to Sin. It determines the amplitude of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.FrontParamB

Deprecated.

The FrontParamB property is relevant when a part's BasePart.FrontSurface is set to Motor or SteppingMotor and BasePart.FrontSurfaceInput is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the frequency of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.FrontSurface

The FrontSurface property determines the type of surface used for the negative Z direction of a part. When two parts' faces are placed next to each other, they may create a joint between them.

BasePart.FrontSurfaceInput

Deprecated.

The FrontSurfaceInput property determines the kind of input provided to a part's BasePart.FrontSurface. This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how BasePart.FrontParamA and BasePart.FrontParamB are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.

• By default, this is set to NoInput. This stops the motor altogether.
• For Constant, the motor rotates at a constant velocity equal to ParamB.
• For Sin, the motor rotates at a velocity equal to ParamA * math.sin(workspace.DistributedGameTime * ParamB). See Workspace.DistributedGameTime.

Code samples: View on Creator Hub (Motor-Control).

BasePart.LeftParamA

Deprecated.

The LeftParamA property is relevant when a part's BasePart.LeftSurface is set to Motor or SteppingMotor and BasePart.LeftSurfaceInput is set to Sin. It determines the amplitude of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.LeftParamB

Deprecated.

The LeftParamB property is relevant when a part's BasePart.LeftSurface is set to Motor or SteppingMotor and BasePart.LeftSurfaceInput is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the frequency of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.LeftSurface

The LeftSurface property determines the type of surface used for the negative X direction of a part. When two parts' faces are placed next to each other, they may create a joint between them.

BasePart.LeftSurfaceInput

Deprecated.

The LeftSurfaceInput property determines the kind of input provided to a part's BasePart.LeftSurface. This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how BasePart.LeftParamA and BasePart.LeftParamB are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.

• By default, this is set to NoInput. This stops the motor altogether.
• For Constant, the motor rotates at a constant velocity equal to ParamB.
• For Sin, the motor rotates at a velocity equal to ParamA * math.sin(workspace.DistributedGameTime * ParamB). See Workspace.DistributedGameTime.

Code samples: View on Creator Hub (Motor-Control).

BasePart.LocalTransparencyModifier

The LocalTransparencyModifier property is a multiplier to Transparency that is only visible to the local client. It does not replicate from client to server and is useful for when a part should not render for a specific client, such as how the player does not see their character's body parts when they zoom into first person mode.

This property modifies the local part's transparency through the following formula, with resulting values clamped between 0 and 1.

1 - ((1 - Transparency) × (1 - LocalTransparencyModifier))

BasePart.Locked

The Locked property determines whether a part (or a Model it is contained within) may be selected in Studio by clicking on it. This property is most often enabled on parts within environment models that aren't being edited at the moment.

Code samples: View on Creator Hub (Recursive-Unlock).

BasePart.Mass

Mass is a read-only property that describes the product of a part's volume and density. It is returned by the GetMass() function.

• The volume of a part is determined by its Size and its Shape, which varies depending on the kind of BasePart used, such as WedgePart.
• The density of a part is determined by its Material or CustomPhysicalProperties, if specified.

BasePart.Massless

If this property is enabled, the part will not contribute to the total mass or inertia of its assembly as long as it is welded to another part that has mass.

If the part is its own root part according to AssemblyRootPart, this will be ignored for that part, and it will still contribute mass and inertia to its assembly like a normal part. Parts that are massless should never become an assembly root part unless all other parts in the assembly are also massless.

This might be useful for things like optional accessories on vehicles that you don't want to affect the handling of the car or a massless render mesh welded to a simpler collision mesh.

See also Assemblies, an article documenting what root parts are and how to use them.

BasePart.Material

The Material property allows you to set a part's texture and default physical properties (in the case that CustomPhysicalProperties is unset). The default Plastic material has a very light texture, while the SmoothPlastic material has no texture at all. Some material textures like DiamondPlate and Granite have very visible textures. Each material's texture reflects sunlight differently, especially Foil.

Setting this property then enabling CustomPhysicalProperties will use the default physical properties of a material. For instance, DiamondPlate is a very dense material while Wood is very light. A part's density determines whether it will float in terrain water.

The Glass material changes rendering behavior on moderate graphics settings by applying a bit of reflectiveness (similar to Reflectance) and perspective distortion. The effect is especially pronounced on sphere-shaped parts. Semi‑transparent parts behind Glass parts are not visible.

BasePart.MaterialVariant

The system searches the MaterialVariant instance with the specified MaterialVariant name and Material type. If it successfully finds a matching MaterialVariant instance, it uses that instance to replace the default material. The default material can be the built-in material or an override MaterialVariant specified in MaterialService.

BasePart.Orientation

The Orientation property describes the part's rotation in degrees around the X, Y, and Z axes using a Vector3. The rotations are applied in Y ⟩ X ⟩ Z order. This differs from proper Euler angles and is instead Tait-Bryan angles which describe yaw, pitch, and roll.

It is also worth noting how this property differs from the CFrame.Angles() constructor which applies rotations in a different order (Z ⟩ Y ⟩ X). For better control over the rotation of a part, it's recommended that CFrame is set instead.

When setting this property, any Welds or Motor6Ds connected to this part will have the matching C0 or C1 property updated to allow the part to move relative to any other parts it is joined to. WeldConstraints will also be temporarily disabled and re-enabled during the move.

Code samples: View on Creator Hub (Part-Spinner).

BasePart.PivotOffset

This property specifies the offset of the part's pivot from its CFrame, that is BasePart:GetPivot() is the same as BasePart.CFrame multiplied by BasePart.PivotOffset.

This is convenient for setting the pivot to a location in local space, but setting a part's pivot to a location in world space can be done as follows:

Code samples: View on Creator Hub (reset-pivot, clock-hands, BasePart-PivotOffset).

BasePart.Position

The Position property describes the coordinates of a part using a Vector3. It reflects the position of the part's CFrame, however it can also be set.

When setting this property, any Welds or Motor6Ds connected to this part will have the matching C0 or C1 property updated to allow the part to move relative to any other parts it is joined to. WeldConstraints will also be temporarily disabled and re-enabled during the move.

BasePart.ReceiveAge

Indicates the time in seconds since the part's physics were last updated on the local client or the server. This value will be 0 when the part has no physics (Anchored is true).

BasePart.Reflectance

The Reflectance property determines how much a part reflects the sky. A value of 0 indicates the part is not reflective at all, and a value of 1 indicates the part should fully reflect.

Reflectance is not affected by Transparency unless the part is fully transparent, in which case reflectance will not render at all. Reflectance may or may not be ignored depending on the Material of the part.

BasePart.ResizeableFaces

The ResizeableFaces property uses a Faces object to describe the different faces on which a part may be resized. For most implementations of BasePart, such as Part and WedgePart, this property includes all faces. However, TrussPart will set its ResizeableFaces set to only two faces since those kinds of parts must have two Size dimensions of length 2.

This property is most commonly used with tools for building and manipulating parts and has little use outside of that context. The Handles class, which has the Handles.Faces property, can be used in conjunction with this property to display only the handles on faces that can be resized on a part.

Code samples: View on Creator Hub (Resize-Handles).

BasePart.ResizeIncrement

The ResizeIncrement property is a read-only property that describes the smallest change in size allowable by the Resize() method. It differs between implementations of the BasePart abstract class; for instance, Part has this set to 1 while TrussPart has this set to 2 since individual truss sections are 2×2×2 in size.

BasePart.RightParamA

Deprecated.

The RightParamA property is relevant when a part's BasePart.RightSurface is set to Motor or SteppingMotor and BasePart.RightSurfaceInput is set to Sin. It determines the amplitude of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.RightParamB

Deprecated.

The RightParamB property is relevant when a part's BasePart.RightSurface is set to Motor or SteppingMotor and BasePart.RightSurfaceInput is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the frequency of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.RightSurface

The RightSurface property determines the type of surface used for the positive X direction of a part. When two parts' faces are placed next to each other, they may create a joint between them.

BasePart.RightSurfaceInput

Deprecated.

The RightSurfaceInput property determines the kind of input provided to a

• For Sin, the motor rotates at a velocity equal to ParamA * math.sin(workspace.DistributedGameTime * ParamB). See Workspace.DistributedGameTime.

Code samples: View on Creator Hub (Motor-Control).

BasePart.RootPriority

This property is an integer between -127 and 127 that takes precedence over all other rules for root part sort. When considering multiple parts that are not Anchored and which share the same Massless value, a part with a higher RootPriority will take priority over those with lower RootPriority.

You can use this property to control which part of an assembly is the root part and keep the root part stable if size changes.

See also Assemblies, an article documenting what root parts are and how to use them.

BasePart.Rotation

The rotation of the part in degrees for the three axes.

When setting this property, any Welds or Motor6Ds connected to this part will have the matching C0 or C1 property updated to allow the part to move relative to any other parts it is joined to. WeldConstraints will also be temporarily disabled and re-enabled during the move.

BasePart.RotVelocity

Deprecated. This property is deprecated. Use AssemblyAngularVelocity instead.

The RotVelocity of a part describes how its BasePart.Orientation is presently changing. In other words, this property describes how the fast part is rotating. The part only rotates if it is not anchored.

The unit of this property is radians per second.

Using this in conjunction with AlignOrientation allows for aligned parts to have matching RotVelocity and Orientation values.

Code samples: View on Creator Hub (rotating-a-part-with-rotvelocity).

BasePart.Size

A part's Size property determines its visual dimensions, while ExtentsSize represents the actual size used by the physics engine, such as in collision detection. The individual dimensions (length, height, width) can be as low as 0.001 and as high as 2048. Size dimensions below 0.05 will be physically simulated as if the part's dimensions are 0.05, while visual rendering preserves the actual size.

A part's Size is used in a variety of additional ways:

• To influence its mass as given by GetMass().
• By ParticleEmitter to determine the area from which particles are spawned.
• By BlockMesh to partially determine the rendered rectangular prism.
• By SpecialMesh for certain MeshTypes to determine the size of the rendered mesh.
• By SurfaceLight to determine the space to illuminate.

Code samples: View on Creator Hub (Pyramid-Builder).

BasePart.SpecificGravity

Deprecated. This item is deprecated. See BasePart.CustomPhysicalProperties to see how to configure the physical properties of BaseParts. Do not use it for new work.

The ratio of the part's density to the density of water determined by the BasePart.Material. Effects the part's behavior when in a water terrain cell. Essentially, SpecificGravity refers to how many times more dense a part is than water.

BasePart.TopParamA

Deprecated.

The TopParamA property is relevant when a part's BasePart.TopSurface is set to Motor or SteppingMotor and BasePart.TopSurfaceInput is set to Sin. It determines the amplitude of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.TopParamB

Deprecated.

The TopParamB property is relevant when a part's BasePart.TopSurface is set to Motor or SteppingMotor and BasePart.TopSurfaceInput is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the frequency of the motor's rotational velocity.

Code samples: View on Creator Hub (Motor-Control).

BasePart.TopSurface

The TopSurface property determines the type of surface used for the positive Y direction of a part. When two parts' faces are placed next to each other, they may create a joint between them.

BasePart.TopSurfaceInput

Deprecated.

The TopSurfaceInput property determines the kind of input provided to a part's BasePart.TopSurface. This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how BasePart.TopParamA and BasePart.TopParamB are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.

• By default, this is set to NoInput. This stops the motor altogether,
• For Constant, the motor rotates at a constant velocity equal to ParamB.
• For Sin, the motor rotates at a velocity equal to ParamA * math.sin(workspace.DistributedGameTime * ParamB). See Workspace.DistributedGameTime.

Code samples: View on Creator Hub (Motor-Control).

BasePart.Transparency

The Transparency property controls the visibility of a part on a scale of 0 to 1 where 0 is completely visible (opaque) and 1 is completely invisible (not rendered at all).

While fully transparent parts are not rendered at all, partially transparent objects have some significant rendering costs. Having many translucent parts may impact performance.

When transparent parts overlap, render order may act unpredictably, so you should avoid semi-transparent parts from overlapping.

See also LocalTransparencyModifier as a multiplier to Transparency that's only visible to the local client.

Code samples: View on Creator Hub (Fade-Door).

BasePart.Velocity

Deprecated. This property is deprecated. Use AssemblyLinearVelocity instead.

The Velocity of a part describes how its BasePart.Position is presently changing. The unit of this property is studs per second. For reference, the default Roblox character moves at 16 studs per second via Humanoid.WalkSpeed. The acceleration due to gravity is found in Workspace.Gravity (by default, -196.2 studs per second per second).

Setting the Velocity of a part that is BasePart.Anchored will cause it to act like a conveyor belt. Any object that touches the part will begin to move in accordance with the Velocity.

Some BodyMover objects will apply forces and thus change the Velocity of a part over time. The simplest of these is a BodyForce which can be used to counteract the acceleration due to gravity on a single part (set the +Y axis of the BodyForce.Force to the product of the mass (BasePart:GetMass()) and the gravity constant).

Code samples: View on Creator Hub (Projectile-Firing).

Methods

Inherited from PVInstance

Inherited from Instance

Inherited from Object

BasePart:AngularAccelerationToTorque

Returns the world-space torque vector that must be applied to the part's assembly to achieve the specified angular acceleration. This result can be used to determine the torque that should be applied via a Torque instance or BasePart:ApplyAngularImpulse().

The calculation uses Euler's rotation equation where I is the assembly's world-space inertia tensor, α is the desired angular acceleration, and ω is the angular velocity.

τ = I · α + ω × (I · ω)

If the part is not a descendant of Workspace, this method returns a vector of infinity. If the assembly is anchored, it similarly returns a vector of infinity.

Gyroscopic Effects

When a spinning assembly has an asymmetric inertia tensor, the torque required to achieve a specified angular acceerlation is augmented due to the changing orientation of the body. The optional angVelocity parameter accounts for these gyroscopic effects. If omitted, these gyroscopic effects are omitted from the calculation.

Parameters

Returns

Code samples: View on Creator Hub (BasePart-AngularAccelerationToTorque).

BasePart:ApplyAngularImpulse

Applies an instant angular force impulse to this part's assembly, causing the assembly to spin.

The resulting angular velocity from the impulse relies on the assembly's mass. So a higher impulse is required to move more massive assemblies. Impulses are useful for cases where you want a force applied instantly, such as an explosion or collision.

If the part is owned by the server, this function must be called from a server Script (not from a LocalScript or a Script with RunContext set to RunContext.Client). If the part is owned by a client through automatic ownership, this function can be called from either a client script or a server script; calling it from a client script for a server-owned part will have no effect.

Parameters

Returns

BasePart:ApplyImpulse

This function applies an instant force impulse to this part's assembly.

The force is applied at the assembly's center of mass, so the resulting movement will only be linear.

The resulting velocity from the impulse relies on the assembly's mass. So a higher impulse is required to move more massive assemblies. Impulses are useful for cases where you want a force applied instantly, such as an explosion or collision.

If the part is owned by the server, this function must be called from a server Script (not from a LocalScript or a Script with RunContext set to RunContext.Client). If the part is owned by a client through automatic ownership, this function can be called from either a client script or a server script; calling it from a client script for a server-owned part will have no effect.

Parameters

Returns

BasePart:ApplyImpulseAtPosition

This function applies an instant force impulse to this part's assembly, at the specified position in world space.

If the position is not at the assembly's center of mass, the impulse will cause a positional and rotational movement.

The resulting velocity from the impulse relies on the assembly's mass. So a higher impulse is required to move more massive assemblies. Impulses are useful for cases where developers want a force applied instantly, such as an explosion or collision.

If the part is owned by the server, this function must be called from a server Script (not from a LocalScript or a Script with RunContext set to RunContext.Client). If the part is owned by a client through automatic ownership, this function can be called from either a client script or a server script; calling it from a client script for a server-owned part will have no effect.

Parameters

Returns

BasePart:BreakJoints

Deprecated. This method is deprecated. To break specific joints, iterate over the part's connections using BasePart:GetJoints() and call Instance:Destroy() on the joints you want to remove.

Breaks any surface connection with any adjacent part, including Weld and other JointInstance.

Returns

BasePart:breakJoints

Deprecated. This deprecated function is a variant of BasePart:BreakJoints() which should be used instead.

Returns

BasePart:CanCollideWith

Returns whether the parts can collide with each other or not. This function takes into account the collision groups of the two parts. This function will error if the specified part is not a BasePart.

Parameters

Returns

BasePart:CanSetNetworkOwnership

The CanSetNetworkOwnership function checks whether you can set a part's network ownership.

The function's return value verifies whether or not you can call BasePart:SetNetworkOwner() or BasePart:SetNetworkOwnershipAuto() without encountering an error. It returns true if you can modify/read the network ownership, or returns false and the reason you can't, as a string.

Returns

Code samples: View on Creator Hub (BasePart-CanSetNetworkOwnership1).

BasePart:GetClosestPointOnSurface

Returns the closest point on the part's surface to the given world-space position. If the provided position is inside the part, it is returned as-is.

For MeshPart and PartOperation instances, this method respects the part's CollisionFidelity value. Return values can differ based on whether the mesh is being treated as a box, a hull, or a more complex shape.

Parameters

Returns

BasePart:GetConnectedParts

Returns a table of parts connected to the object by any kind of rigid joint.

If recursive is true this function will return all of the parts in the assembly rigidly connected to the BasePart.

Rigid Joints

When a joint connects two parts together (Part0 → Part1), a joint is rigid if the physics of Part1 are completely locked down by Part0. This only applies to the following joint types:

• Weld
• Snap
• ManualWeld
• Motor
• Motor6D
• WeldConstraint

Parameters

Returns

BasePart:GetJoints

Return all Joints or Constraints that is connected to this Part.

Returns

BasePart:GetMass

GetMass returns the value of the read-only Mass property.

This function predates the Mass property. It remains supported for backward-compatibility; you should use the Mass property directly.

Returns

Code samples: View on Creator Hub (BasePart-GetMass1).

BasePart:getMass

Deprecated. This Camel Case property has been deprecated in favor of its Pascal Case variant, BasePart:GetMass().

Returns

BasePart:GetNetworkOwner

Returns the current player who is the network owner of this part, or nil in case of the server.

Returns

BasePart:GetNetworkOwnershipAuto

Returns true if the game engine automatically decides the network owner for this part.

Returns

BasePart:GetNoCollisionConstraints

Returns the enabled NoCollisionConstraint objects currently registered for this part in its physics world. A NoCollisionConstraint disables collisions between the two specific parts it references, while each of those parts may still collide with the rest of the world.

The returned array is empty if no such constraint is currently registered for this part. The order of the returned constraints is not guaranteed.

Returns

BasePart:GetRenderCFrame

Deprecated. This item is been deprecated since interpolation is now applied to the CFrame directly. Do not use it for new work.

This function used to be relevant when Roblox's lag-compensating interpolation of parts online was internal. The interpolation is now applied to the CFrame directly.

Returns

BasePart:GetRootPart

Deprecated.

Returns the base part of an assembly. When moving an assembly of parts using a CFrame. it is important to move this base part (this will move all other parts connected to it accordingly). More information is available in the Assemblies article.

This function predates the AssemblyRootPart property. It remains supported for backwards compatibility, but you should use AssemblyRootPart directly.

Returns

BasePart:GetTouchingParts

Returns a table of all parts that are physically interacting with this part. If the part itself has CanCollide set to false, then this function returns an empty table unless the part has a TouchInterest object parented to it (meaning something is connected to its Touched event). Parts that are adjacent but not intersecting are not considered touching. This function predates the WorldRoot:GetPartsInPart() function, which provides more flexibility and avoids the special TouchInterest rules described above. Use WorldRoot:GetPartsInPart() instead.

Returns

BasePart:GetVelocityAtPosition

Returns the linear velocity of the part's assembly at the given position relative to this part. It can be used to identify the linear velocity of parts in an assembly other than the root part. If the assembly has no angular velocity, than the linear velocity will always be the same for every position.

Parameters

Returns

BasePart:IntersectAsync

Creates a new IntersectOperation from the intersecting geometry of the part and the other parts in the given array. Only Parts are supported, not Terrain or MeshParts. Similar to Clone(), the returned object has no set Parent.

The following properties from the calling part are applied to the resulting IntersectOperation:

• Color, Material, MaterialVariant, Reflectance, Transparency
• CanCollide
• Anchored, Density, Elasticity, ElasticityWeight, Friction, FrictionWeight

Migration

It is highly recommended to use the newer GeometryService:IntersectAsync() instead of this method. As well as having better performance and more features, the new method differs as follows:

• The output is an array of instances rather than a single instance.
• The input parts do not need to be parented to the scene, allowing for background operations.
• When the SplitApart option is set to true (default), each distinct body will be returned in its own PartOperation.
• All the returned parts are in the coordinate space of the main part, so their PVInstance.Origin positions are the same as the main part's. This keeps the vertices of the mesh in the same position relative to the object as before the operation, but it does also mean the (0, 0, 0) of a returned part is not necessarily at the center of its body.

Notes

• The original parts remain intact following a successful intersect operation. In most cases, you should Destroy() all of the original parts and parent the returned IntersectOperation to the same place as the calling BasePart.
• By default, the face colors of the resulting intersection are borrowed from the Color property of the original parts. To change the entire intersection to a specific color, set its UsePartColor property to true.
• If an intersect operation would result in a part with more than 20,000 triangles, it will be simplified to 20,000 triangles.

Parameters

Returns

BasePart:IsGrounded

Returns true if the object is connected to a part that will hold it in place (eg an Anchored part), otherwise returns false. In an assembly that has an Anchored part, every other part is grounded.

Returns

BasePart:MakeJoints

Deprecated. SurfaceType based joining is deprecated, do not use MakeJoints for new projects. WeldConstraints and HingeConstraints should be used instead.

Creates a joint on any side of the Part that has a SurfaceType that can make a joint it will create a joint with any adjacent parts.

Joints will be created between the sides and any planar touching surfaces, depending on the sides' surfaces.

• Smooth surfaces will not create joints
• Glue surfaces will create a Glue joint
• Weld will create a Weld joint with any surface except for Unjoinable
• Studs, Inlet, or Universal will each create a Snap joint with either of other the other two surfaces (e.g. Studs with Inlet and Universal)
• Hinge and Motor surfaces create Rotate and RotateV joint instances

Unlike Model:MakeJoints(), this function requires an array of parts as a parameter. This array is given as follows:

part:MakeJoints({part1, part2, part3})

Joints are broken if enough force is applied to them due to an Explosion, unless a ForceField object is parented to the BasePart or ancestor Model. For this reason, they are often used to make simple destructible buildings and other models.

Returns

BasePart:makeJoints

Deprecated. This deprecated function is a variant of BasePart:MakeJoints() which should be used instead.

Returns

BasePart:Resize

Changes the size of an object just like using the Studio resize tool.

Parameters

Returns

BasePart:resize

Deprecated. This deprecated function is a variant of BasePart:Resize() which should be used instead.

Parameters

Returns

BasePart:SetNetworkOwner

Sets the given player as network owner for this and all connected parts. When playerInstance is nil, the server will be the owner instead of a player.

Parameters

Returns

BasePart:SetNetworkOwnershipAuto

Lets the game engine dynamically decide who will handle the part's physics (one of the clients or the server).

Returns

BasePart:SubtractAsync

Creates a new UnionOperation from the part, minus the geometry occupied by the parts in the given array. Only Parts are supported, not Terrain or MeshParts. Similar to Clone(), the returned object has no set Parent.

Note that the resulting union cannot be empty due to subtractions. If the operation would result in completely empty geometry, it will fail.

Migration

It is highly recommended to use the newer GeometryService:SubtractAsync() instead of this method. As well as having better performance and more features, the new method differs as follows:

• The output is an array of instances rather than a single instance.
• The input parts do not need to be parented to the scene, allowing for background operations.
• When the SplitApart option is set to true (default), each distinct body will be returned in its own PartOperation.
• All the returned parts are in the coordinate space of the main part, so their PVInstance.Origin positions are the same as the main part's. This keeps the vertices of the mesh in the same position relative to the object as before the operation, but it does also mean the (0, 0, 0) of a returned part is not necessarily at the center of its body.

Parameters

Returns

BasePart:TorqueToAngularAcceleration

Returns the world-space angular acceleration that would result from applying the specified torque to the part's assembly, optionally taking into account gyroscopic effects.

This is the inverse of BasePart:AngularAccelerationToTorque(). It is useful for predicting how an assembly will respond to an applied torque.

The calculation uses:

α = I⁻¹ · (τ − ω × (I · ω))

where I is the assembly's world-space inertia tensor, τ is the applied torque, and ω is the angular velocity.

If the part is not a descendant of Workspace, returns (0, 0, 0). If the assembly is anchored, returns (0, 0, 0).

Gyroscopic Effects

When a spinning assembly has an asymmetric inertia tensor, the acceleration resulting from an applied torque also depends on the current angular velocity. The angVelocity parameter accounts for these gyroscopic effects. If omitted (defaults to zero), the result neglects this contribution from the result.

Parameters

Returns

Code samples: View on Creator Hub (BasePart-TorqueToAngularAcceleration).

BasePart:UnionAsync

Creates a new UnionOperation from the part, plus the geometry occupied by the parts in the given array. Only Parts are supported, not Terrain or MeshParts. Similar to Clone(), the returned object has no set Parent.

The following properties from the calling part are applied to the resulting UnionOperation:

• Color, Material, MaterialVariant, Reflectance, Transparency
• CanCollide
• Anchored, Density, Elasticity, ElasticityWeight, Friction, FrictionWeight

Migration

It is highly recommended to use the newer GeometryService:UnionAsync() instead of this method. As well as having better performance and more features, the new method differs as follows:

• The output is an array of instances rather than a single instance.
• The input parts do not need to be parented to the scene, allowing for background operations.
• When the SplitApart option is set to true (default), each distinct body will be returned in its own PartOperation.
• All the returned parts are in the coordinate space of the main part, so their PVInstance.Origin positions are the same as the main part's. This keeps the vertices of the mesh in the same position relative to the object as before the operation, but it does also mean the (0, 0, 0) of a returned part is not necessarily at the center of its body.

Notes

• The original parts remain intact following a successful union operation. In most cases, you should Destroy() all of the original parts and parent the returned UnionOperation to the same place as the calling BasePart.
• By default, the resulting union respects the Color property of each of its parts. To change the entire union to a specific color, set its UsePartColor property to true.
• If a union operation would result in a part with more than 20,000 triangles, it will be simplified to 20,000 triangles.

Parameters

Returns

Events

Inherited from Instance

Inherited from Object

BasePart.LocalSimulationTouched

Deprecated. This event is deprecated in favor of BasePart.Touched.

Fired when another part comes in contact with another object. This event only sends data to the client notifying it that two parts have collided, whereas BasePart.Touched sends data to the server.

Parameters

Code samples: View on Creator Hub (BasePart-LocalSimulationTouched1).

BasePart.OutfitChanged

Deprecated. This event is deprecated. Do not use it for new work.

Fired if the part's appearance is affected by the Shirt class.

BasePart.StoppedTouching

Deprecated. This event is deprecated in favor of BasePart.TouchEnded, which should be used instead.

Deprecated. Fires on the local client when a part stops touching another part, under conditions similar to those of BasePart.TouchEnded. This event is the client-only counterpart to BasePart.TouchEnded: it only notifies the local client that the two parts have separated, whereas BasePart.TouchEnded also sends data to the server. Use BasePart.TouchEnded instead.

Parameters

BasePart.Touched

The Touched event fires when a part comes in contact with another part. For instance, if PartA bumps into PartB, then PartA.Touched fires with PartB, and PartB.Touched fires with PartA.

This event only fires as a result of physical movement, so it will not fire if the CFrame property was changed such that the part overlaps another part. This also means that at least one of the parts involved must not be Anchored at the time of the collision.

This event works in conjunction with Workspace.TouchesUseCollisionGroups to specify whether collision groups are acknowledged for detection.

Parameters

Code samples: View on Creator Hub (Touching-Parts-Count, Model-Touched).

BasePart.TouchEnded

Fires when a part stops touching another part under similar conditions to those of BasePart.Touched.

This event works in conjunction with Workspace.TouchesUseCollisionGroups to specify whether collision groups are acknowledged for detection.

Parameters

Code samples: View on Creator Hub (Touching-Parts-Count).