“Tessellation Shaders” standard package has several shaders that use DX11 tessellation.

Linux Publishing

Export a standalone player for 32-bit (x86) or 64-bit (x86_64) Linux.

Select "Linux" from the Target Platform list in the Build Settings.

After building a Linux player on Windows, you will first need to make the binary executable on Linux before being able to run it. Do this by running 'chmod +x' on the executable or right clicking and selecting "Allow to run as application".

Supported Platforms

Standalone players will run on most modern Linux systems with vendor-supplied graphics drivers.

Official support will be provided for 32 or 64-bit Ubuntu Linux, version 10.10 (Maverick Meerkat) or newer, with graphics cards using vendor-supplied drivers.

Meshes can have a non-triangle topology now. You can create meshes that are lines, points or quads from scripts. See MeshTopology enum, Mesh.GetIndices, SetIndices, GetTopology.

Added SkinnedMeshRenderer.BakeMesh to "bake" skinned mesh result into a regular mesh. You can use this to implement semi-instanced crowd rendering schemes.

Graphics: Added resizable window support for standalone builds; see Resizable Window option in player settings.

LOD: Add an API that allows for the construction / configuration of LODs at runtime. You can now add a LODGroup and configure it without using the UI.

Shuriken particle system:

World collision support - world collisions can be high/medium/low quality. High quality raycasts all particles and is expensive. Medium/low quality traces some of the particles, while the rest reuses older collisions. While this is approximate, in many cases where there are a lot of particles it will look fine and perform very well. The ray casting budget is set in quality settings.

Automatic simulation culling support. Particle systems will only update when visible. When it is not possible to support this automatically, Shuriken shows why directly inside the UI.

External forces support - use Wind Zones with particles.

Bent normals support for sprites.

Support for sorting and rendering with immediate children (solving sorting issues for combined systems).

UNITY_NEAR_CLIP_VALUE, defined to 0.0 on D3D-like, -1.0 on GL-like platforms.

UNITY_COMPILER_HLSL (d3d11, 360), UNITY_COMPILER_HLSL2GLSL (gles), UNITY_COMPILER_CG if you need to determine which shader compiler is used on a platform.

UNITY_INITIALIZE_OUTPUT(type,name) to help with DX11 shader compiler requiring full initialization of "out" parameters.

OpenGL ES 2.0: Supports depth textures on Android.

Scripting API: added Texture.SetGlobalAnisotropicFilteringLimits.

New Project Browser (replaces the Project Window)

View assets by preview icons.

Separate tree for folders for better overview of folder structure.

Search for assets using droplists for type and asset labels.

Save searches to favorites list for easy access to most used searches.

Drag folders to favorites list for easy access to most used folders.

Enable searching the Asset Store and previewing assets.

You can switch Project Browser to old-style one column layout in the context menu of the window (upper right corner).

Rewrite of the GUI system

The existing GUI system (OnGUI) had its core rewritten, optimized and cleaned up. It uses less memory and induces less garbage collection cycles. In some cases we’ve seen it being 10x faster without GUILayout, and several times faster than previous version when GUILayout is used.

Note: this is not the “New GUI” that is coming to a later Unity 4.x release. It’s existing GUI, made much faster.

Other Features

Added a new development console to show error messages on screen in development player builds.

Android: Added Eclipse project generation.

Android: Support for APK Expansion Files (OBBs) - effectively enabling applications larger than 50Mb in the Google Play Store.

iOS: Screen.SetResolution now works on iOS too.

iOS: Target Resolution Player Setting was redesigned to better suite development workflow on multiple iOS devices. Two new “Auto (Best performance)” and “Auto (Best Quality)” settings allow Unity Runtime to choose most optimal rendering resolution according to device GPU capabilities.

Debugger: Web players can now be attached to and debugged just like standalones.

Editor: Add components and scripts to Game Objects easier and faster through the new Add Component drop-down directly inside the Inspector.

Editor: Create your own Inspector GUI for custom classes or attributes and see it used across all scripts that use those classes or attributes.

Fonts: Custom fonts can now use arbitrary character rectangles instead of a fixed grid.

Fonts: Font character placement properties are now accessible from scripting.

Fonts: Imported fonts can now be converted to editable custom fonts from the gear menu.

Gradient (known from the Shuriken editor) is now exposed to scripts: Gradient, GradientColorKey, GradientAlphaKey.

Navigation: NavMeshAgent supports prioritized levels of avoidance.

Navigation: NavMeshObstacle component added.

New Cursor API was introduced:

Cursor API supports both software and hardware cursors.

Support for hardware cursors on the following platforms: Windows, Mac OS X, Linux, Flash.

Configure the default cursor in your projects’ Player Settings.

License: New activation system was developed:
Ability to un-license a machine yourself!

Continuous license and content updates.

Unity Account login for certain license types.

Surveys for certain license types.

New Web Player Update mechanism, which allows multiple runtime versions to be installed at the same time:

Allows running beta content with the beta runtime without having to install a beta plugin (beta runtime will be downloaded automatically).

Optionally allows testing release content using the beta runtime (by default it will be played back using the release runtime), using the context menu.

Allows switching between development and non-development players without plugin reinstallations, using the context menu.

Please note: in order for this to work, web plugin bundled with this build must be installed on user machine.

Flash: Assembly validation for Flash supported/unsupported API's. If .NET feature or API is not available the validator will notify the user in the log, before compiling.

Plugins: Added Texture.GetNativeTexturePtr() that you can use in native code plugins. Can now directly access textures on non-OpenGL platforms as well! Example plugin in Low-level Native Plugin Interface documentation page shows how to.

Upgrade guide

We have changed how the active state of GameObjects is handled. GameObjects active state will now affect child GameObjects, so setting a GameObject to inactive will now turn the entire sub-hierarchy inactive. This may change the behavior of your projects. GameObject.active and GameObject.SetActiveRecursively() have been deprecated. Instead, you should now use the GameObject.activeSelf and GameObject.activeInHierarchy getters and the GameObject.SetActive() method.

Android: Removed X<->Y axis mismatch for Android input. Now out of the box it should match iOS input. Requires code refactoring!

Editor: We have reset the preferences from 3.x to 4.x. This affects your saved window layouts, the project wizard list, saved filters etc.

Editor: While an asset is being imported it will not be persistent. E.g. if you postprocess a texture and query its asset path, it will return an empty string. Assets outside of the asset postprocessor can, of course, be accessed at any point.

iOS: Now iOS sensors follow screen orientation. No more complicated code for axis remapping! This can be switched off via Input.compensateSensors. Requires code refactoring!

iOS: Target Resolution Player Setting was redesigned to better suite development workflow on multiple iOS devices. Two new “Auto (Best performance)” and “Auto (Best Quality)” settings allow Unity Runtime to choose most optimal rendering resolution according to device GPU capabilities. Some custom editor scripts might need to be updated to comply with these changes. Rendering resolution might be also changed from game scripts using Screen.SetResolution API.

iOS: Device SDK Player Settings was simplified and now contains only two entries “Device SDK” and “Simulator SDK”. Corresponding editor API entries were also changed and some custom editor scripts might need to be changed.

Target Platform Player Setting was removed from Unity Editor. Now all Unity iOS applications are ARMv7-only. Corresponding PlayerSetting.iOS Editor API entries also were removed. You might need to fix some of your editor scripts for that.

Graphics API level (Open GL ES 1.1 or 2.x) selection was moved to separate Graphics Level Player Setting. This setting is synced with the Android platform.

Applications that were already released to the App Store as supporting ARMv6+ARMv7 or ARMv6-only now can be updated only if Target iOS Version Player Setting is set to “4.3” or higher.

Mobile: Unity 4.0 brings hard shadow support to mobiles. Shadows for mobiles are enabled at the default Quality Setting. And if the project is shared with desktop platforms then shadows might just appear on mobiles too when project gets imported into Unity 4.0. Some manual tweaking of lighting/shadow setup might be required for optimal performance on mobiles.

Runtime: GameObjects marked DontDestroyOnLoad are no longer temporarily deactivate when loading a level. They will also not receive an OnDisable / OnEnable call when loading a level.

Graphics: Unity 4.0 adds a "Read/Write Enabled" option in Mesh import settings. When this option is turned off, it saves memory since Unity can unload a copy of mesh data in the game. However, if you are scaling or instantiating meshes at runtime with a non-uniform scale, you may have to enable "Read/Write Enabled" in their import settings. The reason is that non-uniform scaling requires the mesh data to be kept in memory. Normally we detect this at build time, but when meshes are scaled or instantiated at runtime you need to set this manually. Otherwise they might not be rendered in game builds correctly.

Model importing: The Model Importer in Unity 4.0 has become better at mesh optimization. The "Mesh Optimization" checkbox in the Model Importer in Unity 4.0 is now enabled by default, and will reorder the vertices in your Mesh for optimal performance. You may have some post-processing code or effects in your project which depend on the vertex order of your meshes, and these might be broken by this change. In that case, turn off "Mesh Optimization" in the Mesh importer. Especially, if you are using the SkinnedCloth component, mesh optimization will cause your vertex weight mapping to change. So if you are using SkinnedCloth in a project imported from 3.5, you need to turn off "Mesh Optimization" for the affected meshes, or reconfigure your vertex weights to match the new vertex order.

Editor: The Scene Gizmo axis cones no longer sets the camera to be orthographic. The center cube now toggles orthographic. The label below the gizmo now toggles between perspective and ortho as well. Shift-clicking or middle-mouse clicking the center cube will set the "nice" perspective view and shift-clicking or middle-mouse clicking the cones will enforce ortho.

Android: Fixed an optimization error which could cause javac to crash/fail when loading UnityPlayer class.

Android: SystemInfo.deviceUniqueIdentifier is anonymized by calculating the MD5 sum of IMEI/MEID, ANDROID_ID or WiFi MAC - whichever is available.

Android: SystemInfo.deviceUniqueIdentifier didn't automatically add the right permissions in the manifest.

Android: Switched to Bouncycastle for keystore certificate creation.

Android: On pre-Gingerbread devices 16bit DisplayBuffer is no longer enforced (and fallback from 32bits to 16bits buffer is handled gracefully). Worked around compositor issue with DisplayBuffer alpha on pre-Honeycomb devices.

Android: Made sure Ping cannot hang (times out after 5s).

Android: Added JB (4.1) to the list of SDK APIs.

Android: Fixed crash on Kindle when quitting without ever pausing.

Android: Changing system time/date while application was running would cause an ANR.

Editor: Fixed a bug where ARGB16 textures loaded from AssetBundles built for iOS/Android would load incorrectly.

Editor: Editor doesn't hang anymore if exiting while in play mode.

Editor: Made entering playmode faster by reducing the number of domain reloads.

Editor: Fixed null reference exception when a MonoBehaviour is missing in the inspector. Instead we display helpful warnings embedded in the inspector.

Editor: Fixed issue in fbx importer where prefab instance modifications would in some corner cases get applied to a different object on a different machine

Editor: Fixed bug where calling LoadLevel in OnDestroy when exiting playmode could lead to a crash.

Editor: Fixed bug where the import settings were not updated when a .meta file is changed.

Editor: Fixed various leaks in the asset import pipeline when importing large project folders.

Editor: Fixed prefab override recording issue where modifications would not get applied to array elements if the prefab array is empty and the size value was overridden after the property was overridden.

Editor: Fixed warning when changing import settings on a lot of fbx files.

Editor: Fixed crashbug when clicking on Apply prefab button in the game object inspector when the prefab would add / remove components on awake in edit mode.

Graphics: Fixed Camera pixelWidth/pixelHeight/aspect queries done from Editor code being really confusing. Before, it was using the size of last drawn editor view for the calculations. Now, for regular cameras, Game View size is used.

Graphics: Fixed crash in Shuriken mesh particles, when source mesh has no normals or tangents.

Graphics: Fixed errors with statically batched meshes that are later modified by a script.

Graphics: Fixed various issues with shaders in asset bundles. E.g. you can actually put terrain with trees into an asset bundle, and the billboard shaders will work, without having to jump through various hoops.

Graphics: Properly include all shaders into game data files when editor is in "-nographics" mode.

Graphics: Batched Shuriken draw calls were not accounted for in the game view stats window.

Mac OS X Standalone: Used OS X Lion style fullscreen mode, to allow other windows to show up in front of fullscreen apps, and to allow switching in and out of fullscreen mode by clicking onto the fullscreen button in the window title bar (optional).

Scripting: Added overloads to EditorGUI.IntSlider so it can take SerializedProperties.

Scripting: Fixed crash when calling material.GetFloat(null).

Scripting: Fixed crash when a component destroys itself while AddComponent is trying to create it.

Scripting: Fixed crash calling Resources.Load before resources have been imported.

Scripting: Fixed bug where AssetBundle.LoadFromFile would get unloaded by UnloadUnusedAssets.

Scripting: GameObject.Find will now correctly find children of objects of the same name as other objects which don't have children of that name.

Scripting: Fixed crash when a gameObject is being destroyed while calling SendMessage on it.

Scripting: Fixed script serialization bug where properties could not be #if-ed out for the player.

Serialization: For non-webplayer-targets, scenes (implicitly) referencing assets placed under the Resources folder will now always have the assets placed together with the scene (and not in the resources.assets).

Shaders: Fog shader variables (unity_FogColor etc.) are set to produce no fog when it's off.

Shaders: round() and trunc() HLSL functions are now supported when compiling shaders for mobile.