Improved Internationalization and Localization

==============================================

Commiting GSoC project by Xiangquan Xiao trunk.

Applied as separated patch, because svn merge produces to much false
conflicts and worked really slow.

Details for usage would be published on code.blender.org soon.

Thanks to Xiao for implementation of project, Campbell to code review,
Dalai and Gez for pointing to nice font and everybody else who took
part in improving i18n support.

114 files changed, 8815 insertions, 2415 deletions

diff --git a/SConstruct b/SConstruct
index 3432a7b71ba..01522b3ae29 100644
--- a/SConstruct
+++ b/SConstruct
@@ -512,8 +512,10 @@ datafilestargetlist = []
 dottargetlist = []
 scriptinstall = []
 
-if  env['OURPLATFORM']!='darwin':
-        for dp, dn, df in os.walk('bin/.blender'):
+if env['OURPLATFORM']!='darwin':
+        for dp, dn, df in os.walk('release/bin/.blender'):
+            dp = os.path.normpath(dp)
+
             if '.svn' in dn:
                 dn.remove('.svn')
             if '_svn' in dn:
@@ -529,14 +531,14 @@ if  env['OURPLATFORM']!='darwin':
                     if f.endswith('.ttf'):
                         continue
                 
-                if 'locale' in dp:
+                if 'locale' in dp or 'fonts' in dp:
                     datafileslist.append(os.path.join(dp,f))
-                    dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['datafiles'] + dp.split(os.sep)[1:]))    # skip bin
+                    dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['datafiles'] + dp.split(os.sep)[3:]))    # skip bin
                     datafilestargetlist.append(dir + os.sep + f)
 
                 else:
                     dotblendlist.append(os.path.join(dp, f))
-                    dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['config'] + dp.split(os.sep)[1:]))    # skip bin
+                    dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['config'] + dp.split(os.sep)[3:]))    # skip bin
                     dottargetlist.append(dir + os.sep + f)
                     
         dotblenderinstall = []
diff --git a/po/POTFILES.in b/po/POTFILES.in
new file mode 100644
index 00000000000..4c791dd9369
--- /dev/null
+++ b/po/POTFILES.in
@@ -0,0 +1,222 @@
+release/scripts/modules/rna_prop_ui.py
+
+release/scripts/startup/bl_operators/animsys_update.py
+release/scripts/startup/bl_operators/object.py
+release/scripts/startup/bl_operators/object_align.py
+release/scripts/startup/bl_operators/object_quick_effects.py
+release/scripts/startup/bl_operators/object_randomize_transform.py
+release/scripts/startup/bl_operators/presets.py
+release/scripts/startup/bl_operators/screen_play_rendered_anim.py
+release/scripts/startup/bl_operators/sequencer.py
+release/scripts/startup/bl_operators/wm.py
+
+release/scripts/startup/bl_ui/properties_animviz.py
+release/scripts/startup/bl_ui/properties_data_armature.py
+release/scripts/startup/bl_ui/properties_data_bone.py
+release/scripts/startup/bl_ui/properties_data_camera.py
+release/scripts/startup/bl_ui/properties_data_curve.py
+release/scripts/startup/bl_ui/properties_data_empty.py
+release/scripts/startup/bl_ui/properties_data_lamp.py
+release/scripts/startup/bl_ui/properties_data_lattice.py
+release/scripts/startup/bl_ui/properties_data_mesh.py
+release/scripts/startup/bl_ui/properties_data_metaball.py
+release/scripts/startup/bl_ui/properties_data_modifier.py
+release/scripts/startup/bl_ui/properties_game.py
+release/scripts/startup/bl_ui/properties_material.py
+release/scripts/startup/bl_ui/properties_object_constraint.py
+release/scripts/startup/bl_ui/properties_object.py
+release/scripts/startup/bl_ui/properties_particle.py
+release/scripts/startup/bl_ui/properties_physics_cloth.py
+release/scripts/startup/bl_ui/properties_physics_common.py
+release/scripts/startup/bl_ui/properties_physics_field.py
+release/scripts/startup/bl_ui/properties_physics_fluid.py
+release/scripts/startup/bl_ui/properties_physics_smoke.py
+release/scripts/startup/bl_ui/properties_physics_softbody.py
+release/scripts/startup/bl_ui/properties_render.py
+release/scripts/startup/bl_ui/properties_scene.py
+release/scripts/startup/bl_ui/properties_texture.py
+release/scripts/startup/bl_ui/properties_world.py
+
+release/scripts/startup/bl_ui/space_console.py
+release/scripts/startup/bl_ui/space_dopesheet.py
+release/scripts/startup/bl_ui/space_graph.py
+release/scripts/startup/bl_ui/space_image.py
+release/scripts/startup/bl_ui/space_info.py
+release/scripts/startup/bl_ui/space_logic.py
+release/scripts/startup/bl_ui/space_nla.py
+release/scripts/startup/bl_ui/space_node.py
+release/scripts/startup/bl_ui/space_outliner.py
+release/scripts/startup/bl_ui/space_sequencer.py 
+release/scripts/startup/bl_ui/space_text.py
+release/scripts/startup/bl_ui/space_time.py
+release/scripts/startup/bl_ui/space_userpref.py
+release/scripts/startup/bl_ui/space_userpref_keymap.py
+release/scripts/startup/bl_ui/space_view3d.py
+release/scripts/startup/bl_ui/space_view3d_toolbar.py
+
+source/blender/editors/animation/anim_channels_edit.c
+source/blender/editors/animation/anim_markers.c
+source/blender/editors/animation/anim_ops.c
+source/blender/editors/animation/drivers.c
+source/blender/editors/animation/keyframing.c
+source/blender/editors/animation/keyingsets.c
+
+source/blender/editors/armature/armature_ops.c
+source/blender/editors/armature/editarmature.c
+source/blender/editors/armature/editarmature_sketch.c
+source/blender/editors/armature/poselib.c
+source/blender/editors/armature/poseobject.c
+source/blender/editors/armature/poseSlide.c
+
+source/blender/editors/curve/editcurve.c
+source/blender/editors/curve/editfont.c
+
+source/blender/editors/gpencil/gpencil_paint.c
+
+source/blender/editors/interface/interface_layout.c
+source/blender/editors/interface/interface_ops.c
+source/blender/editors/interface/interface_regions.c
+source/blender/editors/interface/interface_templates.c
+source/blender/editors/interface/interface_utils.c
+source/blender/editors/interface/view2d_ops.c
+
+source/blender/editors/mesh/editmesh.c
+source/blender/editors/mesh/editmesh_add.c
+source/blender/editors/mesh/editmesh_loop.c
+source/blender/editors/mesh/editmesh_mods.c
+source/blender/editors/mesh/editmesh_tools.c
+source/blender/editors/mesh/loopcut.c
+source/blender/editors/mesh/mesh_data.c
+source/blender/editors/mesh/mesh_ops.c
+
+source/blender/editors/metaball/mball_edit.c
+
+source/blender/editors/object/object_add.c
+source/blender/editors/object/object_constraint.c
+source/blender/editors/object/object_edit.c
+source/blender/editors/object/object_group.c
+source/blender/editors/object/object_lattice.c
+source/blender/editors/object/object_modifier.c
+source/blender/editors/object/object_ops.c
+source/blender/editors/object/object_relations.c
+source/blender/editors/object/object_select.c
+source/blender/editors/object/object_shapekey.c
+source/blender/editors/object/object_transform.c
+source/blender/editors/object/object_vgroup.c
+
+source/blender/editors/physics/particle_edit.c
+source/blender/editors/physics/particle_object.c
+source/blender/editors/physics/physics_pointcache.c
+
+source/blender/editors/render/render_internal.c
+source/blender/editors/render/render_opengl.c
+source/blender/editors/render/render_shading.c
+source/blender/editors/render/render_view.c
+
+source/blender/editors/screen/area.c
+source/blender/editors/screen/screendump.c
+source/blender/editors/screen/screen_ops.c
+
+source/blender/editors/sculpt_paint/paint_ops.c
+source/blender/editors/sculpt_paint/paint_image.c
+source/blender/editors/sculpt_paint/paint_utils.c
+source/blender/editors/sculpt_paint/paint_vertex.c
+source/blender/editors/sculpt_paint/sculpt.c
+
+source/blender/editors/sound/sound_ops.c
+
+source/blender/editors/space_action/action_edit.c
+source/blender/editors/space_action/action_ops.c
+source/blender/editors/space_action/action_select.c
+
+source/blender/editors/space_buttons/buttons_header.c
+source/blender/editors/space_buttons/buttons_ops.c
+
+source/blender/editors/space_console/console_ops.c
+
+source/blender/editors/space_file/file_draw.c
+source/blender/editors/space_file/file_ops.c
+source/blender/editors/space_file/file_panels.c
+
+source/blender/editors/space_graph/graph_buttons.c
+source/blender/editors/space_graph/graph_edit.c
+source/blender/editors/space_graph/graph_ops.c
+source/blender/editors/space_graph/graph_select.c
+
+source/blender/editors/space_image/image_buttons.c
+source/blender/editors/space_image/image_ops.c
+
+source/blender/editors/space_info/info_ops.c
+source/blender/editors/space_info/info_report.c
+source/blender/editors/space_info/space_info.c
+
+source/blender/editors/space_logic/logic_buttons.c
+
+source/blender/editors/space_nla/nla_buttons.c
+source/blender/editors/space_nla/nla_channels.c
+source/blender/editors/space_nla/nla_edit.c
+source/blender/editors/space_nla/nla_select.c
+
+source/blender/editors/space_node/node_buttons.c
+source/blender/editors/space_node/node_edit.c
+source/blender/editors/space_node/node_header.c
+source/blender/editors/space_node/node_ops.c
+source/blender/editors/space_node/node_select.c
+source/blender/editors/space_node/node_state.c
+
+source/blender/editors/space_script/script_edit.c
+
+source/blender/editors/space_sequencer/sequencer_add.c
+source/blender/editors/space_sequencer/sequencer_buttons.c
+source/blender/editors/space_sequencer/sequencer_edit.c
+source/blender/editors/space_sequencer/sequencer_select.c
+
+source/blender/editors/space_text/text_header.c
+source/blender/editors/space_text/text_ops.c
+source/blender/editors/space_time/time_ops.c
+
+source/blender/editors/space_view3d/view3d_buttons.c
+source/blender/editors/space_view3d/view3d_draw.c
+source/blender/editors/space_view3d/view3d_edit.c
+source/blender/editors/space_view3d/view3d_fly.c
+source/blender/editors/space_view3d/view3d_header.c
+source/blender/editors/space_view3d/view3d_select.c
+source/blender/editors/space_view3d/view3d_view.c
+source/blender/editors/space_view3d/view3d_toolbar.c
+
+source/blender/editors/transform/transform.c
+source/blender/editors/transform/transform_ops.c
+source/blender/editors/transform/transform_orientations.c
+
+source/blender/editors/util/undo.c
+
+source/blender/editors/uvedit/uvedit_ops.c
+source/blender/editors/uvedit/uvedit_unwrap_ops.c
+
+source/blender/makesrna/intern/rna_ID.c
+source/blender/makesrna/intern/rna_action.c
+source/blender/makesrna/intern/rna_color.c
+source/blender/makesrna/intern/rna_constraint.c
+source/blender/makesrna/intern/rna_curve.c
+source/blender/makesrna/intern/rna_fcurve.c
+source/blender/makesrna/intern/rna_material.c
+source/blender/makesrna/intern/rna_mesh.c
+source/blender/makesrna/intern/rna_modifier.c
+source/blender/makesrna/intern/rna_object.c
+source/blender/makesrna/intern/rna_object_force.c
+source/blender/makesrna/intern/rna_particle.c
+source/blender/makesrna/intern/rna_render.c
+source/blender/makesrna/intern/rna_scene.c
+source/blender/makesrna/intern/rna_space.c
+source/blender/makesrna/intern/rna_texture.c
+source/blender/makesrna/intern/rna_ui_api.c
+source/blender/makesrna/intern/rna_userdef.c
+source/blender/makesrna/intern/rna_wm.c
+source/blender/makesrna/intern/rna_wm_api.c
+source/blender/makesrna/intern/rna_world.c
+
+source/blender/windowmanager/intern/wm_files.c
+source/blender/windowmanager/intern/wm_operators.c
+source/blender/windowmanager/intern/wm_window.c
+
+
diff --git a/po/messages.txt b/po/messages.txt
new file mode 100644
index 00000000000..b491061cdc4
--- /dev/null
+++ b/po/messages.txt
@@ -0,0 +1,5433 @@
+The edited object
+Bezier curve point with two handles defining a Keyframe on an F-Curve
+Max Climb
+Media Stop
+System & OpenGL
+Strips Selected
+Active Keying Set
+Action Blending
+Bone is able to be selected
+Defines where the color of the environment light comes from
+Display files as short list
+Build 75% proxy resolution
+Right Mouse
+Cubic Catmull-Rom
+Particle system can be edited in particle mode
+UV editor data for the image editor space
+Editing hair
+Zoom using opposite direction
+Graph Editor space data
+Create obstacle
+Tiles
+Align newly added objects to the world coordinates
+Index of custom color set
+Sample point for F-Curve
+AVI Raw
+Linear Drag
+Color to display the marker with
+Channels Region
+Lower bound of envelope at this control-point
+Fluid
+Regions this area is subdivided in
+Double Click
+Disable simulation of linear motion along the X axis
+Sequencer OpenGL
+Child particles generated by the particle system
+Point in a shape key for curves
+Lock to Bone
+Sun Size
+Set modifier expanded in the user interface
+Multiple Scattering
+ID Name
+Steering
+Animation Visualisation
+Keyed States
+Fixed size vertex indices array
+Normal Size
+Track To
+Time since last access of a GL texture in seconds after which it is freed. (Set to 0 to keep textures allocated.)
+Collection of keymaps
+Texture datablocks
+Number of vertical pixels in the screen
+Fluid Simulation
+Zooms in and out like scaling the view, mouse movements relative to center
+Lattice Edit
+Snap onto its self (editmode)
+Only render what's in front of the solid z values
+True when multiple enums 
+Backdrop Zoom
+Causes mesh data to be duplicated with the object
+Automatic
+Small Caps
+UV Project
+UV Sync Selection
+Cloth dynamics for hair
+File Browser Main
+Sensitivity
+Amount of rotation around side vector
+Specify how many frames the Map Old will last
+Start Still
+Unique datablock ID name
+Active pose marker for this Action
+Draw Channels
+Smoothens emitted smoke to avoid blockiness
+Tool Settings
+Text Line
+Bone Constraints
+Toggle whether the material is linked to object data or the object block
+Falloff power for transmissivity filter effect (1.0 is linear)
+Only use case sensitive matches of search string
+Screw
+Region Text
+Representation of alpha information in the RGBA pixels
+Edges receive a drag force from surrounding media
+Sequence Transform
+Over Drop
+Domain Settings
+New F-Curve Colors - XYZ to RGB
+Space that owner is evaluated in
+Frame Step
+Enumeration
+Value of the item
+Parent of this pose bone
+B-Bone Z size
+Up Arrow
+For reactor systems, the object that has the target particle system (empty if same object)
+Shift key pressed
+Auto Refresh
+Bone Color Sets
+Positive values make strands rounder, negative makes strands spiky
+Collection of images
+Show actuators of active object
+interpolate a global timestamp using the record date and time written by recording device
+Main Lattices
+Variable from some source/target for driver relationship
+Z Location
+Auto-Clamped handle selected color
+Fixed Alternate
+Game engine sensor to detect events
+Include the frame number in image metadata
+Bone does not deform any geometry
+UV Textures
+Game
+Minimal Spring length * Ball Size
+16384
+Line in which the marker is located
+Offset X
+Rasterized cell height
+Edge Threshold
+-Z
+Set audio channels to mono
+Jump Speed
+HuffYUV
+Active Bone
+View3D Fly Modal
+Sets the audio channel count
+Rotation Damping
+Max Air Acceleration
+Snap center onto target
+Spring Damping
+Compact with Milliseconds
+Maintain speed, flight level or wander
+Interpolation type
+Type Info
+SIMD QBVH
+active
+Armature
+Match case
+16 Bit
+XZY Rotation Order. Prone to Gimbal Lock
+Auto handle selected color
+Theme File Browser
+Bake the normals in object space
+Enable color range used for weight visualization in weight painting mode
+Vorticity
+Open window
+Shows sensors for this object in the user interface
+Radius of head of bone (for Envelope deform only)
+Plain diffuse energy (white.)
+Elasticity
+Cache Step
+View Sliders
+Hair
+Filter Movies
+Material datablock used by this material slot
+Smooth Emitter
+Catalan (Català)
+RVO (cells)
+Home
+Action Mouse
+Show Debug Info
+Loads a saved environment map image from disk
+is_baking
+Scene datablocks
+Wire
+Group
+On Land
+Group Objects
+Time Step
+Keep UI
+Bone inherits rotation or scale from parent bone
+Show Selected Object
+Theme settings for the Outliner
+Time of key over the simulation
+Header Text
+Health
+Similar to SMPTE (Compact), except that instead of frames, milliseconds are shown instead
+Blender Original
+Deliver texture UV pass
+Index number of the vertex
+Stepped Interpolation
+Adds diagonal springs on 4-gons
+Shear
+Tent
+Strength of force field
+Space that target is evaluated in
+F11
+Star
+Library datablocks
+Line Input
+Lighten
+In Range
+Use Blender units for widths instead of pixels
+F17
+Node Socket
+Quad-Buffer
+Sets scaling for the texture's X, Y and Z sizes
+F14
+Motion Path settings for animation visualisation
+Make hairs longer
+Set audio sample format to 32 bit float
+Amount of anti-aliasing samples per pixel
+type
+Use optimized Bullet DBVT tree for view frustum and occlusion culling
+Make this surface a closed loop in the V direction
+Alpha Over
+Media player for video & png/jpeg/sgi image sequences
+Second input for the effect strip
+Space Logic Editor
+Snap during transform
+Edit Methods
+Left Handle
+B-Bone Ease Out
+Cyclic Offset
+Subtype
+Object Base
+Vertex Group Clump
+Letterbox
+Set audio channels to 7.1 surround sound
+V
+Quaternion (WXYZ)
+Image File
+Preset configs for external animation players
+Maximum Value
+Make this nurbs curve or surface act like a Bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)
+uk_UA
+3x3 bone matrix
+Vertex Weight
+Display Material
+Use a custom transform orientation
+GLSL Shaders
+Text
+Deliver shadow pass
+From node
+Keyframes
+Main Brushes
+Deliver diffuse pass
+Header
+Level detector, trigger controllers of new states(only applicable upon logic state transition)
+Collision Compound
+Increment
+Trackball
+Active Strip
+Initial Rest Length
+User defined layer of string text values
+Edge Tag Mode
+Invert tilt Axis
+Deliver emission pass
+Face Selected
+Xor
+Voronoi Crackle
+Align the transformation axes to the window
+Line sample
+Default Goal (vertex target position) value, when no Vertex Group used
+Type of raytrace accelerator structure
+Area Spaces
+Project individual elements on the surface of other objects
+Use the angle between two bones
+Aero
+Zmask
+Set audio sample format to 32 bit signed integer
+Scene render size
+Multiplier to convert blender units to physical distance
+Free Image Textures
+Metaball datablocks
+DPI
+Fill in Z values for solid faces in invisible layers, for masking
+Active Action for this datablock
+Use turntable style rotation in the viewport
+Format
+Use a Catmull-Rom filter for anti-aliasing
+Link material to object or the object's data
+Type of participation in the fluid simulation
+face normal
+Enable
+Final 4x4 matrix after constraints and drivers are applied (object space)
+Diameter of widget, in 10 pixel units
+ID Property
+Radius of tail of bone (for Envelope deform only)
+Custom Shape Transform
+Action FCurves
+Envelope Deform Weight
+A
+Renders star shaped lines over halo
+Fade-out Color
+Syntax Built-in
+Samples below this threshold will be considered fully shadowed/unshadowed and skipped (for Raytrace Adaptive QMC)
+Camera datablocks
+Bounding Box Center
+Middle Mouse
+Framerate base
+Touch
+Vortex
+Manipulator Size
+F-Curve Colors - XYZ to RGB
+Invert Output
+Calculate heights against unsubdivided low resolution mesh
+Shrinkwrap
+Window Deactivate
+Y position of the sequence strip
+The frame on which this sketch appears
+Snap to increments of grid
+Rest Length
+All
+Serbian (Српском језику)
+Sample Method
+Text Anti-aliasing
+Only allows given density value in emitter area
+Sequencer Preview Shading
+Lower field first
+File Name
+Show timing in seconds not frames
+Display the object as wire edges
+Billboard with Z-axis constraint
+Curves
+Displays clock frequency of fullscreen display
+X Rotation
+Sphere
+Select UVs that share mesh vertex, irrespective if they are in the same location
+8 bit RAW
+0.5 means no distance at all, 1.0 is maximum distance
+Sequencer
+Max Ghost Range
+An object instance in a scene
+User Interface
+Alt
+Vertex group name
+PNG
+Animated Selected
+Blue
+Damping of the spring force, when inside the physics distance area
+Plugin Strip
+Hide
+Pose Matrix
+Guide-free time from particle life's end
+Frame is being edited (painted on)
+Large Cursors
+Limit Rotation
+Draw only faces with the currently displayed image assigned
+Record Run
+Pixel width over which the reconstruction filter combines samples
+Global Scene
+Defines the structure of the header in the UI
+Source List Text Highlight
+User-editable keyframes
+Scaling factor for action
+Inner
+Active Constraint
+Side-by-side
+Right Arrow
+Causes the 1 to 0 keys to act as the numpad (useful for laptops)
+A collection of pose channels, including settings for animating bones
+Lennard-Jones
+Use a maximum radial distance for the field to work
+Location of tail end of the bone relative to armature
+Edit All
+estimate matrix .. split to COM , ROT ,SCALE 
+Use Coordinates
+Theme User Preferences
+Show line numbers next to the text
+Minimum speed in air (relative to maximum speed)
+Display keymap datablocks
+,
+Display Summary
+Channel Driver (only set for Driver F-Curves)
+Item
+In/Out Node
+Frame that modifier's influence ends (if Restrict Frame Range is in use)
+Premultiplied
+Number of frames cached
+Description of the Struct's purpose
+Tilt in 3D View
+Show Debug
+Offsets image horizontally from the world origin
+region_data
+Protect layer from further editing and/or frame changes
+File Format
+Retarget roll mode
+IK rot control
+Upper bound of envelope at this control-point
+Interaction Radius
+Syntax String
+Vertex group to control density
+Show Overexposed
+Vertices
+Kerning Style
+IK X Minimum
+Sets the factor by which the flare is larger than the halo
+Absolute ball size or factor if not manual adjusted
+Blend Opacity
+Steps
+Texture
+Settings for the visualisation of motion
+Group of vertices, used for armature deform and other purposes
+Limit Distance
+Minus
+No interpolation, fast but blocky and low quality
+Control
+Full SMPTE timecode. Format is HH:MM:SS:FF
+Open On Mouse Over
+Show sensors of active object
+Frame Server Port
+Noise patterns will remain unchanged, faster and suitable for stills
+Start
+RLE (lossless)
+True when the property is not saved in presets
+Images are rendered in new Window
+Theme Timeline
+If this is set, the header gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_HT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_HT_hello"
+The color that rays with no intersection within the Max Distance take (material color can be best for indoor scenes, sky color for outdoor)
+Show Cursor
+Goal Default
+Shape Key Point
+Object Origin Size
+Orthographic
+Invert y axis
+Unit Scale
+Collection of points for Bezier curves only
+Mouse
+Pivot Point
+UV Layer to control billboard splitting
+Only insert keyframes where they're needed in the relevant F-Curves
+IK Z Minimum
+Distance
+Key rotation quaternion
+Backscattered light
+Texture effector weight
+Volume rendering settings for a Material datablock
+Which output node to use, for node-based textures
+Handle 1 selection status
+Always render a still frame from the voxel data sequence
+Factor
++Z
+Numpad 4
+Type
+Action Groups
+Styles
+rv
+Recast data for a Game datablock
+Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)
+Description of the property for tooltips
+Area in a subdivided screen, containing an editor
+IK Z Maximum
+Effect fader position
+Particle System to render as points
+Vertex Group Size Negate
+Simplify Subdivision
+Warp
+3D View center is locked to this bone's position
+Enable cluster collision between soft and rigid body
+04 - Theme Color Set
+Lamps
+Color Picker Type
+Location of the hair key in its internal coordinate system, relative to the emitting face
+Properties Space
+The view mode to use for displaying sequencer output
+Hold
+Prefetch Frames
+Pose Tail Position
+Amount of pixels to extend the baked result with, as post process filter
+Dummy
+Deliver full combined RGBA buffer
+Long Key Selected
+Extension
+Complete Matches Only
+Lines
+The external source data file to use
+The time (in minutes) to wait between automatic temporary saves
+Undo Memory Size
+Type of event mapping
+Animation Data
+Unique node identifier
+Draw white edges
+Show Menus
+W
+Inverse Kinematics
+Number of times a map will be rendered recursively (mirror effects.)
+Face Mask
+Density is calculated as a factor of default density (depends on particle size)
+Soft
+Use a maximum distance for the field to work
+Has IK
+Power of Fresnel for transparency (Ray or ZTransp)
+Name of PoseBone to use as target
+Display files as thumbnails
+Transparency blending mode
+Multiple Engines
+Bits
+Active Boid Rule Index
+Child Of
+Metric
+Proxy size 100%
+Module name
+Visible
+NLA Strip references some Action
+Average screen dimension of stars
+Converter Node
+Mirror
+Method of calculating aerodynamic interaction
+Curl
+Main Objects
+Only include channels relating to selected objects and data
+Set audio mixing buffer size to 256 samples
+Bake normals
+Uses direction of strands as normal for tangent-shading
+Textbox Width
+Pose
+Plasticity
+Object scale factor
+Boid effector weight
+Mass Vertex Group
+Fight
+Adjust the offset to the beginning/end
+Bone Solid
+NLA Strip representing a sound event for speakers
+Maximum contour edge length
+Build free run time code index using Record Date/Time
+End frame displayed in the sequence editor after offsets are applied
+NLA Strip acts as a container for adjacent strips
+Offsets image vertically from the world origin
+Block anything else from using the cursor
+Inverse Lift
+Maximum for slider
+Mode of automatic keyframe insertion for Objects and Bones (default setting used for new Scenes)
+Render Solid faces in this Layer
+Vertex Weight Edit
+Rotation style in the viewport
+Active Vertex Color Index
+Show the active object's smoke cache
+Action Extrapolation
+Resolution X
+Mesh
+Progress Bar Widget Colors
+Lock editing of rotation in the interface
+Draw faces over the image
+Press
+Weight Color Range
+Collection of vertex colors
+Thickness of strokes (in pixels)
+Resolution V
+Particle Target
+Object duplicate transformation matrix
+Luma
+Blend Out
+B
+B-Bone X size
+Anti-Aliasing Level
+Handle Vertex Size
+IK Lin Weight
+Negative
+End Still
+Y Offset
+Edge
+Amount of stickness to surface collision
+Bone Matrix
+Randomizes ring dimension and line location
+Velocity
+Respect the frame rate rather than rendering as many frames as possible
+Distance to the view location
+High res
+Object to take point data from
+Falloff type for proportional editing mode
+Region width
+Border Minimum Y
+Flash Video
+Active Section
+Channel defining pose data for a bone in a Pose
+Smoothed high quality interpolation, but slower
+Sets the audio sample rate
+Deliver raytraced refraction pass
+Land Personal Space
+Curve Splines
+Operating system key pressed
+14 - Theme Color Set
+Grease pencil data for this space
+Child particle interpolated from simulated or edited particles
+Editor header containing UI elements
+Select Head
+Catmull-Rom
+GLSL Nodes
+Make edges 'sail'
+Scattering
+Wire Select
+Unit
+Bezier Points
+Frame on which the simulation starts
+Animation Player
+Sequence Crop
+Autoname
+Dying
+Floor
+True when the property is hidden
+Cache Compression
+Keep Root
+Render Output Directory
+Multiple Caches
+External Shadows
+Points V
+Show Debug Properties
+White Level
+Framing Color
+Line Feed
+Logarithmic dissolve
+Circle
+Show movie files
+Maximum distance for the field to work
+Vertex Group Kink
+Enable anisotropic friction
+Use color management for GLSL rendering
+Exec Screen
+Render Layer
+Validity
+Show sensors of all selected objects
+Tessellation
+-
+F-Curve Modifier's effects will be tempered by a default factor
+Paths Type
+Cine-Scope 24fps 2048x858
+Use Mist
+Object Duplicate Matrix
+Repulsion force to apply on cloth when close to colliding
+Marker is temporary
+Collection of screens
+Lock X Axis
+Octree Resolution
+Control how much mist density decreases with height
+Custom Color Set
+Texture Context
+Active Vertex Group
+Disallow movement around the Y axis
+Edge Color
+Datablocks
+Channels of the image to draw
+2D Cursor
+Constant QMC
+Shape Key Curve Point
+Command output
+turbulence_strength
+Color used for active bones
+3D View center is locked to this object's position
+Vertex groups of the object
+Weights for the vertex groups this vertex is member of
+Invert Axes
+Euler Rotation
+Material to override all other materials in this render layer
+Tag Sharp
+Is part of an IK chain
+Output image in JPEG format
+Main Groups
+Slider Min
+Side
+Bone
+Square (HV + S)
+Transforms include effects of parenting/restpose and constraints
+Name of operator to call on input event
+Particle Speed
+Motion Blur
+Nurb V-lines
+Font size to use for displaying the text
+Tools
+Float
+Dynamic
+Scene
+Color curve mapping to use for displaying the image
+Set audio channels to 4 channels
+Free handle color
+16-bit Signed
+Active object for this scene
+Previous Angular Velocity
+Material Link To
+Solid Light
+Property Value
+Worldspace distance over which to blend in the surface normal
+NLA Strip is active
+Mini Axis Size
+Multiply direct lighting with ambient occlusion, darkening the result
+Moving things with a mouse drag confirms when releasing the button
+Show Render
+Camera this timeline sets to active
+Update Automatically
+Inwards component of the vortex force
+Edit texture nodes from Brush
+Current perspective matrix of the 3D region
+Opaque
+Goal (vertex target position) friction
+All rules are averaged
+Grease Pencil Stroke
+Display Object Info
+The maximum distance from which a boid can attack
+Curve interpolation at this point: Bezier or vector
+Both Z
+Textbox Y Offset
+Node group datablocks
+Ogg Theora
+Logic And
+Identifier of operator to call on input event
+Spaces contained in this area, the first being the active space. NOTE: Useful for example to restore a previously used 3d view space in a certain area to get the old view orientation
+Set audio channels to stereo
+Order V
+View & Controls
+Rec Run
+Upward spring force, when inside the physics distance area
+Mesh Texture Face Layer
+Transformation orientation
+Gives a radial field toward the center of object
+layout
+Extend
+Collision margin for soft body. Small value makes the algorithm unstable
+box radius
+Cache Index
+Free
+Inbetween Move
+Packed File
+Capsule
+UV projector used by the UV project modifier
+F-Curve Modifier has invalid settings and will not be evaluated
+Dopesheet
+Only Selected
+Replace Text
+Freq
+Sets maximum Y value for the render border
+Compositing nodes
+Waveform Opacity
+Layers that contain something
+Skip Save
+Same Types
+Include Missing NLA
+Level
+Free Unused Nodes
+Maximum distance to apply repulsion force, must be greater then minimum distance
+Display tooltips
+Hold RMB Open Toolbox Delay
+Random variation of friction
+Proportional Editing Falloff
+Object Modifiers
+Logic Xnor
+Move to center of neighbors and match their velocity
+Stretch or squeeze the viewport to fill the display window
+X
+Show frame numbers of Keyframes on Motion Paths
+Shaded
+Enhance the resolution of smoke by this factor using noise
+Backdrop
+Selected
+Refraction Exclude
+Enable bitmap text on face
+Button4 Mouse
+The direction that the OpenGL light is shining
+Images are rendered without forcing UI changes, optionally showing result
+A circular Hue/Saturation color wheel, with Value slider
+Input 3
+Input 2
+Input 1
+Engine to use for rendering
+Active UV Texture Index
+Include the render time in the stamp image
+Disabled
+Sets the amount mirror reflection for raytrace
+Game Object Settings
+Clear
+Max Physics Steps
+Find All
+3D View far clipping distance
+Activate or deactivate item
+Blobby element in a MetaBall datablock
+Only Render
+Radius of the agent
+Show Navigation Guide
+Default Colors
+Sets the dimension of the sub-flares, dots and circles
+Dynamic Friction
+fi_FI
+Viewpoint Object
+Display the object solid, lit with default OpenGL lights
+Use Global Coordinates
+Use the initial length as spring rest length instead of 2 * particle size
+Priority
+Render polygon transparent, depending on alpha channel of the texture
+Active File
+Manually determine the number of threads
+User Defined
+Vertex group to control clump
+Enable/Disable Constraint
+Object is detected by the Near and Radar sensor
+VBOs
+When false, this (sub)layout is greyed out
+Select Mouse
+The Drivers/Expressions for this datablock
+Individual Centers
+Enables automatic saving of preview images in the .blend file (Windows only)
+Shape key in a shape keys datablock
+Use left Mouse Button for selection
+Pivot around the 3D cursor
+Auto
+Registered
+Flares Sub
+Short List
+Sounds Directory
+Interpolate
+Game engine properties
+Allow drawing multiple strokes at a time with Grease Pencil
+Output image in (old!) SGI IRIS format
+Left Alt
+Sub Level Menu Open Delay
+Number of frames at start of strip to fade in influence
+Keyframe Points
+Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point
+Display error text
+Vertex group for fine control over structural stiffness
+RNA Path (from ID-block) to property used
+Info
+User preferences space data
+C
+Emit Exclude
+Thumbnails
+Collision Sensor, detects static and dynamic objects but not the other collision sensor objects
+Lamp Sky Settings
+3D View center is locked to the cursor's position
+Manoeuvre to avoid collisions with other boids and deflector objects in near future
+Global gravity weight
+Curve or Surface subdivisions per segment
+The nominal number of game frames per second. Physics fixed timestep = 1/fps, independently of actual frame rate
+Back scattering (-1.0) to Forward scattering (1.0) and the range in between
+Library Path
+Calculate shadows while rendering
+Defines the strength of environment light
+Mux packet size (byte)
+Croatian (Hrvatski)
+Separate Colors
+Collider Friction
+Goal minimum, vertex group weights are scaled to match this range
+Gamma Cross
+Driver for the value of a setting based on an external value
+Unit System
+Highlight Line
+Constraint is the one being edited 
+Draw F-Curves using Anti-Aliasing and other fancy effects. Disable for better performance
+Keying Set
+UV Local View
+Changing edges seam re-calculates UV unwrap
+View3D Move Modal
+Any Type
+Image Paint
+Set audio mixing buffer size to 16384 samples
+Creates turbulence with a noise field
+Active EditBone
+Brush
+Show only sensors connected to active states
+Disable simulation of angular  motion along the Z axis
+3D View Generic
+Shape used as a relative key
+World Stars
+Use Environment Lighting
+X Location
+Auto Save Temporary Files
+Surface subdivisions per segment
+Output image in OpenEXR format
+Center
+Air has normally some thickness which slows falling things down
+Defines if the panel has to be open or collapsed at the time of its creation
+Parameters for the function
+Keep root keys unmodified
+Interpolate new particles from the existing ones
+Include visualization of Node related Animation data
+25%
+Sets the number of simulation substep per physic timestep, higher value give better physics precision
+Space in which transforms are used
+16x
+Sets the number of images of a movie to use
+Callback function defines for built-in Keying Sets
+20 - Theme Color Set
+How much heat effects smoke motion, higher value results in faster rising smoke
+Display when not linked to a visible states controller
+Collection of scenes
+256
+Smooth View
+Choose shading information to bake into the image
+Sets the number of star shaped lines rendered over the halo
+Textures
+Active spline
+Maximum bending stiffness value
+Eye Separation
+Window event timer
+Armature EditBones
+Game engine actuators to act on events
+End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)
+Quad Split
+Auto handles clamped to not overshoot
+How much the spring has to be stretched/compressed in order to change it's rest length
+Show Brush On Surface
+.
+Defines the structure of the panel in the UI
+Handle 2 selected
+Use lights for GLSL rendering
+Groups
+Textured
+Camera rotation in horizontal axis
+Blender RNA
+Type of ID-block that can be used
+Column number to show right margin at
+Game Soft Body Settings
+Activity Culling
+Local Space
+Sets the layer as active for rendering
+Rotate From Normal
+IK Y Lock
+Amount of influence constraint will have on the final solution
+The window relative horizontal location of the mouse
+Set audio mixing buffer size to 2048 samples
+Lighting Mode
+Object to use as projector transform
+Numpad -
+Location to store the proxy files
+Add directed noise to the density at render-time
+Physics Sub Steps
+Mesh Faces
+Apply on spline
+Armature Sketch
+Render Halos in this Layer (on top of Solid)
+Nla Strips
+Weight used by the Bevel modifier
+Color range used for weight visualization in weight painting mode
+Boid Rules
+Delay between repeated pulses(in logic tics, 0=no delay)
+Billboard Time Index UV
+Game Data
+IK X Limit
+Theora
+Hook
+Collection of materials
+Lifetime mapped as 0.0 - 1.0 intensity
+Property Editor
+Vorbis
+Allow Land
+Tip select mode
+Navigation Mesh
+Limit the texture size to save graphics memory
+Game engine user defined object property
+Sticky vertex selection disabled
+Display an isolated sub-set of objects, apart from the scene visibility
+Straight Alpha
+Wheel Out
+Sequence Proxy
+Text displayed and edited in this space
+Custom Object
+Numpad +
+Menu
+Active Point Cache Index
+Starting frame of the stored range
+Panel Style
+Emphasize position of keyframes on Motion Paths
+Libraries
+Restrict Frame Range
+Quadratic Drag
+Display X Axis
+Copy of the colors associated with the group's color set
+Use a Mitchell-Netravali filter for anti-aliasing
+ID of the item
+Marker selection state
+Good smoothness and speed
+Use Onion Skinning
+Draw type for drawing UV edges
+id
+Result strip replaces the accumulated results by amount specified by influence
+Transform Space
+Speed factor
+Collection of group sockets
+Highlight Keyframes
+Hide files/datablocks that start with a dot(.*)
+Use 3D transform manipulator
+Value of shape key at the current frame
+Python
+Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)
+Perspective Matrix
+Meta strip stack, last is currently edited meta strip
+Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point
+Auto Keyframe Insert Keying Set
+2D Cursor Location
+Vertex Weight Mix
+Group Index
+Add hairs
+Bake textures
+Crop to Border
+Initial boid health when born
+When rendering animations, save JPG preview images in same directory
+The number of grid lines to display in perspective view
+Worlds
+The distance between 3D View grid lines
+Vector font datablocks
+Tag Bevel
+Negate the effect of the kink vertex group
+Use viscoelastic springs instead of Hooke's springs
+Frameserver Port for Frameserver Rendering
+Shows actuators for this object in the user interface
+Show Info
+Grease Pencil Euclidean Distance
+Pixels moved by mouse per axis when drawing stroke
+Color balance parameters for a sequence strip
+Collision Quality
+Triple Buffer
+Face is used for shadow
+Include visualization of World related Animation data
+Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory
+Regular Widget Colors
+Y
+Bezier Curve Point
+To node
+Puff Mode
+Root
+Deliver Z values pass
+Coordinates of the control point
+Transforms don't include parenting/restpose or constraints
+Keying Set Path
+Friction force if a collision happened. (higher = less movement)
+Theme settings defining draw style and colors in the user interface
+MPEG-4(divx)
+Display reference images behind objects in the 3D View
+Collection of Node Links
+Follow Leader
+Hide objects on these layers when generating the Environment Map
+Line Number
+Fields per Frame
+Harmonic Damping
+Weight hair particles
+Use the Blender internal rendering engine for rendering
+Rotation/Scaling Pivot
+Minimum radial distance for the field's fall-off
+Duration
+Causes curve data to be duplicated with the object
+Absolute
+pt_BR
+Active Layer
+YCbCr (ITU 601)
+Average distance between any two stars
+Multitexture materials
+GLSL
+Current Scene
+How many keys to make new particles with
+Hide element
+Main Meshes
+Text character formatting settings
+Main Material
+Collection of object modifiers
+Maximal resolution used in the fluid domain
+Amount of light that gets emitted by the volume
+Grid
+Use For Growing Hair
+Parent edit bone (in same Armature)
+Use a column layout for toolbox
+Sort by time
+When transforming strips, changes to the animation data are flushed to other views
+Theme settings for widget color sets
+Inner Thickness
+Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)
+Constant Jittered
+Weight to assign in vertex groups
+Bone Armature-Relative Matrix
+Rest length of the harmonic force
+user_preferences
+Gimbal
+Alpha Under
+RNA property definition
+YXZ Euler
+Use shadows for GLSL rendering
+IOR
+Gives the flare extra strength
+Editor menu containing buttons
+Right handle selection status
+Minimum Value
+Action referenced by this strip
+Display and edit the grease pencil freehand annotations overlay
+Path edit mode
+Smooth falloff
+Preferences related to viewing data
+Max Edge Error
+A square showing Hue/Value, with Saturation slider
+D
+Material slot in an object
+Set audio sample format to 8 bit unsigned integer
+User defined integer number value in an integer properties layer
+Output image to a frameserver
+Single Layer
+Radius of boids personal space in air (% of particle size)
+YCbCr (Jpeg)
+Length
+Specular
+Proportional Editing using connected geometry only
+Convex Hull
+Mid-range quality and speed
+Scale of the added turbulent noise
+Only use complete matches of search string
+Show Splash
+Wind
+Repulsion Force
+Method used to convert stroke to bones
+Show Pose Markers
+Frame on which the simulation stops
+Warp Data
+Key angular velocity
+select_start
+Show Linked to Controller
+Struct in which this struct is always nested, and to which it logically belongs
+Include a custom note in image metadata
+Log conversion gamma
+Transform Orientation
+Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems)
+Which style to use for font kerning
+Fall-Off
+Render voxels from a Blender smoke simulation
+Draw the points which make up the strokes (for debugging purposes)
+Frames
+Original image height
+Use face for collision and ray-sensor detection
+Around Frame
+Image Strip
+Bounding Box
+Device up/down directly controls your Z position
+The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed
+Original image width
+Show Margin
+Transform Modal Map
+Stiff Quads
+System
+Spherical Panoramic
+Onion Skinning settings for animation visualisation
+KeyMap Items
+Valid
+MP2
+Handle 2 Type
+Italic
+Material Raytrace Mirror
+Object Grouped Active
+Use Frame Rate
+sv_SE
+Samples
+Name
+Material mode to use for rendering
+Cube
+Result color of the volume, after other light has been scattered/absorbed
+Use Min
+Display the center and axis during rotation
+Multiplier for intensity values
+Render Edge-enhance in this Layer (only works for Solid faces)
+Material datablocks
+/
+Arabic (العربية)
+Most compact representation. Uses '+' as separator for sub-second frame numbers, with left and right truncation of the timecode as necessary
+Filter 2D
+Lift
+Lighting for a World datablock
+External
+Collection of metaballs
+Sets the hardness of the halo
+General rotation damping
+Constraint name
+Hardness
+Syntax highlight for scripting
+Parameters and Settings for the Filebrowser
+Edit Path
+Rot Matrix
+Global Time
+Grease Pencil Manhattan Distance
+Grouping Method
+Lock view rotation in side views
+Effector Group
+Collection of armature edit bones
+Flare
+Control Point selected
+Freehand curves defining the sketch on this frame
+Make this nurbs surface act like a Bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)
+Operator
+Near
+Use the pinned context
+Display files as a detailed list
+On Selected Bones Only
+Has Reports
+Property
+Collection of related sketches
+Control point mass values
+Chance that the particle will pass through the mesh
+Sticky Selection Mode
+Font
+Key Modifier
+Clip
+Edit texture nodes from Object
+resolution_y
+Storage of an operator being executed, or registered after execution
+Image
+Density Scale
+Active Render Layer
+Space DopeSheet Editor
+Maximal
+Indirect Factor
+Pixel Filter
+Upper field first
+Static
+AVI
+Internal Friction
+Global Hair
+Level height
+Bake Specular colors
+DopeSheet space data
+Registered Optionally
+Causes actions to be duplicated with the object
+Enable collisions with other objects
+Theme settings for the Properties
+Region ID
+Strength
+Use nodes for GLSL rendering
+General Mass value
+Damping Factor
+Show Paint
+Weight of a particle dupliobject in a group
+Shows controllers for this object in the user interface
+Allow the use of colors indicating constraints/keyed status
+Target Object
+Texture Paint
+Defines how AO mixes with material shading
+Driver Variable
+Wrap words if there is not enough horizontal space
+Point in a shape key for Bezier curves
+Directory/name to save animations, # characters defines the position and length of frame numbers
+Follow Path
+Use a cubic filter for anti-aliasing
+Media First
+Use so the operator grabs the mouse focus, enables wrapping when continuous grab is enabled
+Draw Frames
+Length of rays, defines how far away other faces give occlusion effect
+Lock Scale
+Method of attenuating density by distance from the point
+8-bit Unsigned
+File Paths
+Point Source
+cs_CZ
+Pose Space
+Sort the file list alphabetically
+Provides an alternative access to loc/scale/rotation relative to the parent and own rest bone
+Collision Type
+Collection of node trees
+Occlusion Resolution
+Apply sun effect on sky
+Stamp Note Text
+Traditional Chinese (繁體中文)
+Scene layers included in this render layer
+Weight used by the Bevel modifier 'Only Vertices' option
+IK Y Stiffness
+The default directory to search for texture plugins
+Vertex Group Velocity Negate
+Modifiers
+Invoke Region Window
+Auto Perspective
+Module
+The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions
+Display Camera
+Subdivisions
+Blendfile Data
+Location of custom proxy file
+Solidify
+Do a full redraw each time, slow, only use for reference or when all else fails
+Horizon Spread
+06 - Theme Color Set
+Show a visualization of physics bounds and interactions
+Z
+Quick Cache
+Show Error
+Left
+Property that stores arbitrary, user defined properties
+UV 4
+Resolution %
+Scattering color
+UV 1
+UV 3
+UV 2
+Handle 2
+Display datablocks in visible layers
+Handle 1
+Left handle selection status
+Active Keying Set Index
+SMPTE (Full)
+Use textures to affect material properties
+Draw Modified Edges
+Maximum caused damage on attack per second
+Shape Key
+Enable file compression when saving .blend files
+Script datablocks (DEPRECATED)
+Frame rate for the screencast to be played back
+MPEG-1
+Use Sketching Sessions
+MP3
+Use ObColor instead of vertex colors
+Lock X Rotation Axis
+Envelope Tail Radius
+Causes armature data to be duplicated with the object
+The menu label
+Allow Flight
+Keyed timing
+Free Run (rec date)
+Use a 3D manipulator widget for controlling transforms
+Insert Keyframes - Only Needed
+Show handles of Bezier control points
+Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)
+Inverse Quadratic
+ru_RU
+Use the value from some RNA property (Default)
+Calculate point velocities automatically
+Actions
+Modifiers affecting all the F-Curves in the referenced Action
+Enables automatic saving of preview images in the .blend file
+Animation Player Preset
+16 - Theme Color Set
+Vector handle color
+Proxy render size
+Clip Max X
+Clip Max Y
+Open in thumbnail view for images and movies
+Physics Engine
+Description
+Sort files by size
+Particle Cache
+Action Influence
+Envelope
+View Perspective
+IK X Maximum
+Boid States
+Display datablocks of selected objects
+Full Sample
+Animation data for datablock
+Channel
+Interpolation mode used for first keyframe on newly added F-Curves. Subsequent keyframes take interpolation from preceeding keyframe
+Order U
+Timecode
+Distance moved by mouse when drawing stroke (in pixels) to include
+Calculate radiosity in a pre-process before rendering
+Selected to Active
+For RGB curves, the color that black is mapped to
+Mesh Texture Face
+E
+For Pose-Mode drawing, only draw ghosts for selected bones
+Landing Smoothness
+Grease Pencil Frame
+Shift
+Mouse Move
+Button 3
+Auto-detect
+Space Timeline Editor
+Only Selected Keyframes Handles
+Use smoke density as texture data
+Operator has a set of reports (warnings and errors) from last execution
+Layered
+Object Vertices
+Set audio mixing buffer size to 512 samples
+Duplicate Metaball
+Saves this datablock even if it has no users
+Cine-Scope 48fps 2048x858
+Ad-hoc correction for over-occlusion due to the approximation
+Line Info
+Filtering Group
+Choose the method used to split a quad into 2 triangles for baking
+Menu Item Colors
+Blending factor for Fresnel
+Constant
+Mitchell-Netravali
+Color
+Button 8
+IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC
+Include visualization of Camera related Animation data
+Free Run
+Opacity of the points
+Button 9
+Collection of speakers
+Adaptive QMC
+Layers the object base is on
+NLA Generic
+Sort by size
+Friend
+Velocity Min
+The brightness of the icon
+Show the active object's cloth point cache
+Invoke Default
+Amplification
+Display warnings
+Realtime
+Size of the font used when rendering stamp text
+Refraction
+Third input for the effect strip
+Snap to vertices
+Global child particles percentage
+Faces collide too, can be very slow
+Disable collision for this object
+Disable the time difference between fields
+The default directory to search for loading fonts
+Automatic keyframe insertion in available curves
+Bake the normals in camera space
+Show Header
+layers
+Color for all strokes in this layer
+Top Level Menu Open Delay
+Exec Area
+Auto Render
+Type of periodic offset on the curve
+Key location
+Use scaled and grid-fitted kerning distances
+Stars setting for a World data-block
+Burn
+Set audio sample format to 24 bit signed integer
+Standard
+0
+Tag Crease
+Image Sequence
+Function is registered as callback as part of type registration
+UV Layer to control billboard normals
+Auto-Keying Mode
+Bitrate
+Back scattering weight
+Select where rendered images will be displayed
+The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent
+Gamma Corrected Color
+AutoMerge Keyframes
+Hold the first frame if no previous strips in track, and always hold last frame
+Active PoseChannel constraint
+Scene Bases
+Vertex Colors
+Collection of mesh faces
+string
+Live search filtering string
+Sequencers active strip
+Number of scene samples to take with motion blur
+Vertex Group for pinning of vertices
+Display libraries
+The number of fields per rendered frame (2 fields is 1 image)
+Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source)
+Frame of referenced Action to evaluate
+Line Error
+Plus
+Coordinates
+Roll CW
+Envelope Control Point
+Invert roll Axis
+Source List Text
+The file extension used for saving renders
+Last selected element
+Radial falloff power (real gravitational falloff = 2)
+Face Normal
+Fluid Simulation Settings
+Disable or enable the render layer
+Tap
+Active Bone Group
+Show render related properties
+Number of vertical pixels in the rendered image
+Child of this pose bone
+Location of Center of mass
+Show background image in back view
+Max Land Acceleration
+3D View
+Snap to actual frames/seconds (nla-action time)
+Two-side
+Tag
+Enables Anti-aliasing
+Smoke domain settings
+Tab
+Default Closed
+SPH Fluid Settings
+Dome physical configurations
+Theme settings for the User Preferences
+Front-Truncated
+Has the current session been saved to disk as a .blend file
+12 - Theme Color Set
+Box
+Constraint modifying the transformation of objects and bones
+Curve datablocks
+Adjustment Layer
+Velocity Scale
+Field of View of the Dome - it only works in mode Fisheye and Truncated
+Jitter
+Audio Window
+Use Grease Pencil
+Filter Blender
+Start frame displayed in the sequence editor after offsets are applied, setting this is equivalent to moving the handle, not the actual start frame
+Create springs for this number of frames since particles birth (0 is always)
+Label
+Object this base links to
+Apply channel rotation as IK constraint
+PCM
+Percentage
+Render Sky in this Layer
+Red
+pl_PL
+Datablock whose nodes are being edited
+Draw user interface text anti-aliased
+Head
+Subdivide stroke in bones of specific length
+Use the depth under the mouse to improve view pan/rotate/zoom functionality
+Texture to use as force
+RNA type definition
+PIZ (lossless)
+Bit depth per channel
+Billboard Split UV
+Pxr24 (lossy)
+Region height
+Heat
+Particle select and display mode
+Normalized
+Mux Packet Size
+Diameter in Pixels for Object/Lamp origin display
+Distance between subsequent volume depth samples
+Swap the Mouse Wheel zoom direction
+Sequence editor space data
+The context in which the panel belongs to. (TODO: explain the possible combinations bl_context/bl_region_type/bl_space_type)
+Bake from Multires
+Start size of strands in pixels or Blender units
+Shape Key datablocks
+Targa
+Particle Instance
+Bezier V
+Multiplier to bring particle speed within an acceptable range
+Collision Group
+Limit effectors to this Group
+Display datablocks of all objects of same type as selected object
+The constraint is applied relative to the local coordinate system of the object, with the parent transformation added
+Deliver normal pass
+Location of tail end of the bone
+The transformation of the target is evaluated relative to the world coordinate system
+File Path
+O
+FLAC
+UV Layer to control billboard time index (X-Y)
+Blender Units
+Vertex Group Tangent Negate
+Set color of selected color stop
+Pivot center for rotation/scaling
+Set audio sample format to 16 bit signed integer
+Zooms in and out based on horizontal mouse movement
+Invert Zoom
+Alpha Mode
+bl_use_postprocess
+Land Stick Force
+Create empty placeholder files while rendering frames (similar to Unix 'touch')
+Face Collision
+Automatic keyframe insertion for Objects and Bones
+Damp
+Disable simulation of angular  motion along the X axis
+RNA Array Index
+Unsigned Number
+Output video in MPEG format
+Dead
+Text Widget Colors
+Auto Save Time
+Freehand curve defining part of a sketch
+Header Text Highlight
+Seed
+True when the Ctrl key is held
+Raytrace Acceleration Structure
+Which direction is used to calculate the effector force
+Addon Key Configuration
+Data point for freehand stroke curve
+Number of cone samples averaged for blurry reflections
+F8
+Filter Sound
+Mass of cloth material
+Matrix
+Action Group that this F-Curve belongs to
+Subdivide stroke adaptively, with more subdivision in curvier parts
+How many steps to draw the path with
+Space Text Editor
+Handle Vertex
+Render face two-sided
+Mist uses inverse quadratic progression
+DV
+Has Maximum
+Skip Quad to Triangles
+Number of times to repeat the action range
+Maximum Distance
+is_baked
+Amount of damping during collision
+F9
+8192
+X Offset
+Image Pin
+Accuracy of attack
+Continuously unwrap the selected UV island while transforming pinned vertices
+Collection of grease pencils
+Gesture Border
+Exclude raytraced reflection pass from combined
+Choose normal space for baking
+Boid state for boid physics
+Occluder for optimizing scene rendering
+Axis Angle
+Field settings for an object in physics simulation
+Rotation Mode
+Active Spline
+Buoyancy
+Element of a curve, either Nurbs, Bezier or Polyline or a character with text objects
+Start player with a visible mouse cursor
+Bars
+Armatures active edit bone
+Breakdown
+Color Mode
+Diffuse
+01 - Theme Color Set
+Start position of the marker in the line
+Consider objects as whole when finding volume center
+Iris
+Save Buffers
+Time Scale
+Split quads predictably (1,2,3) (1,3,0)
+Constraint
+Display Hidden
+Receive shadows from sources outside the volume (temporary)
+Required
+Domain
+Display Speaker
+GLSL Ramps
+Point data to use as renderable point density
+Keyframe insertion only when keyframe needed
+Audio Sample Rate
+Area width
+Time
+Texture datablock used by this texture slot
+Draw Waveform
+DPX
+Expression
+Voxel data settings
+Constraints
+State Colors
+Influence setting is controlled by an F-Curve rather than automatically determined
+Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method)
+Set audio sampling rate to 48000 samples per second
+Order of video fields. Select which lines get rendered first, to create smooth motion for TV output
+Surface Diffuse
+Magnetic
+Stamp Background
+Radius of the activity bubble, in Manhattan length. Objects outside the box are activity-culled
+Show Warn
+When bone has a parent, bone's head is struck to the parent's tail
+Timer 0
+Timer 1
+Timer 2
+Display Y Axis
+Frame player from IRIDAS
+Children
+Zoom To Mouse Position
+Shadows
+Use High Quality Drawing
+Exclude emission pass from combined
+Invert rotation axis
+Plane
+Drivers
+Particle system in an object
+Shader Nodes
+Z-Buffer
+Soft to Soft Body
+Expanded in the user interface
+After Current
+Mix
+Object Color
+Fresnel
+Main Cameras
+Atmosphere Extinction
+Use Indirect Lighting
+Elastic Limit
+Material Slot
+Resolution of raytrace accelerator. Use higher resolutions for larger scenes
+Falloff Power
+Mesh Deform
+Show influence curves on strips
+Tweak timing for physics to control frequency and speed
+IK X Stiffness
+Theme settings for the File Browser
+Images are saved with RGB (color) data
+1
+Textured Fonts
+Data type of the property
+Gain
+Scale X
+Is Perspective
+Metaball
+IK Z Stiffness
+B-Bone Display X Width
+Space Console
+Handle type for handles of new keyframes
+Left Mouse
+Macro
+Average
+Curve
+Sketches for this layer on different frames
+User interface layout in a panel or header
+Error Tolerance
+Axis of mouse movement to zoom in or out on
+Disable auto (de)activation in physics simulation
+Softness
+Inherit Scale
+Graph Editor
+Method of shading, attenuating, and scattering light through the volume
+View
+Position Iterations
+H.264
+Romanian (Român)
+Still Frame Number
+Extension Filter
+Vertex Group Roughness End Negate
+Specular Colors
+Minimal Info
+Face selection mode
+Reflection Color
+Node Editor
+Proportional distance over which the light is diffused
+Use Local Coords
+Zmask Negate
+Property that gives the name of the struct
+Rotation in quaternions (keep normalized)
+On Keyframes
+Pulse False Level
+Animated
+Main Grease Pencils
+Alpha Sort
+Factor for ambient occlusion blending
+Active vertex color index
+Generator
+Author
+Restrict Animation Updates
+Lock editing of four component rotations by components (instead of as Eulers)
+NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)
+The diffuse color of the OpenGL light
+Do not calculate lighting and shadows
+Max Sample Error
+Cut
+Starting distance of the mist, measured from the camera
+Damping
+Push an undo event (needed for operator redo)
+White
+Sets the strength of the add effect
+Collection of lamps
+Animation
+Parent bone (in same Armature)
+Environment Maps
+Inputs
+Direction
+Max difference in heights of obstacles to enable their interaction
+group
+75%
+Hide this curve in editmode
+Deformed Location
+Include visualization of Lattice related Animation data
+Weighted result of strip is multiplied with the accumulated results
+Cloth Settings
+Sharp edge for the EdgeSplit modifier
+Collection of groups
+window
+Preset
+Theme Outliner
+Fast Navigate
+Draw Smooth Edges
+Collection of curves
+Star Tips
+NLA Evaluation Enabled
+3D Cursor Location
+Spline Bezier Points
+Stereo
+Page Up
+Negate the effect of the field vertex group
+Collide All
+Items Expanded
+Marker for noting points in the timeline
+Z Direction
+Causes lamp data to be duplicated with the object
+Scene Strip
+Boid state name
+Simulation value to be used as a texture
+64-bit Float
+Domain Object
+Right
+Shape of clumping
+XZY Euler
+Group Sockets
+Individual pose bones for the armature
+Min Step
+Manipulator Scale
+Main Armatures
+Die Time
+Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)
+Placeholders
+name
+Unfitted
+Minimum regions size. Smaller regions will be merged
+Mesh Selection Mode
+Method to draw in the sequencer view
+Mute
+Down Arrow
+Render Strands in this Layer
+Child Particles
+Duplicate Action
+IK Param
+Main Images
+Weight for cloth simulation
+Index number of the vertex group
+Collection of NLA Tracks
+Sequence strip data for a single frame
+Sculpt/Paint Use Unified Strength
+Audio Mixing Buffer
+ID-block that the specific property used can be found from (id_type property must be set first)
+Linear physics
+Use Collision Bounds
+Passes
+Noise algorithm - Original Perlin: Smooth interpolated noise
+Additive
+Handle 2 selection status
+Trigger controllers only for an instant, even while the sensor remains true
+Loose edge
+Edit animation/keyframes displayed as 2D curves
+Sculpt/Paint Use Unified Radius
+Index to the specific property affected by F-Curve if applicable
+Main Window Managers
+Unit to use for displaying/editing rotation values
+Editmode bone in an Armature datablock
+Bending Stiffness Maximum
+Selection state of the curve point
+Enable pinning of cloth vertices to other objects/positions
+Shared
+Zoom = Up/Down
+NLA Strips
+Text to search for with the find tool
+Use a DCI Standard preset for saving jpeg2000
+Blend Mode
+Space Sequence Editor
+Textures Directory
+Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes
+Include the name of the active scene in image metadata
+F-Curve Name Filter
+Time in 1/10 seconds to hold the Right Mouse Button before opening the toolbox
+pin_id
+Fluid interaction radius
+NLA Strip 'transitions' between adjacent strips
+Editable
+Emission
+Template armature that will be retargeted to the stroke
+Selection status
+Texture slot defining the mapping and influence of a texture
+Connected
+Key
+Align the transformation axes to world space
+Transform parameters for a sequence strip
+Layer Opacity
+Use the Bullet physics engine
+Method for generating shadow samples (for Raytrace)
+Effect particles' dynamic rotation
+Show options for whether channels related to certain types of data are included
+G
+Collection of group objects
+Make hairs shorter
+Show properties marked for debugging while the game runs
+Invert x axis
+Greek (Ελληνικά)
+Smooth
+Sync view position between side views
+Used Layers
+Active File Text
+F18
+F19
+Force effector weight
+The distance over which the mist effect fades in
+Edge Select
+F12
+F13
+F10
+Display Meshes
+F16
+Options
+Grease Pencil datablocks
+F15
+Output video in AVI JPEG format
+Sky Color
+blend_data
+Temporary Directory
+Current rendering engine is a game engine
+100%
+Vertex Group Roughness 2
+IK Rot Weight
+Handle Type
+Bevel Weight
+F-Curve Modifier Type
+int
+No Sleeping
+Save TIFF with 16 bits per channel
+ID Property Group
+Island selection mode
+Collection of texts
+Edges collide too
+512
+Sets minimum Y value for the render border
+Mouse X Position
+Active screen showing in the window
+Stamp Note
+Number of horizontal tiles to use while rendering
+Tilt
+Child Particle
+Action Start Frame
+Media Last
+Pass in multilayer image
+Back Space
+Outflow
+Active Boid State Index
+Enable cluster collision between soft and soft body
+Instance support leads to effective memory reduction when using duplicates
+Xvid
+Realtime display of a modifier
+Sets the layer as active for display and editing
+Wireframe
+Grease Pencil Eraser Radius
+Accurate, but slow when noise-free results are required
+Syntax Special
+Repeat
+Global undo works by keeping a full copy of the file itself in memory, so takes extra memory
+Strength of noise
+Vertical
+Separate
+Self Friction
+Snap median onto target
+Area
+Falloff
+REC709
+Smooth the normals of the surface or beveled curve
+2D View Minimum Grid Spacing
+Font Style
+Image datablocks
+3D region in this space, in case of quad view the camera region
+Sound datablocks
+Auto Velocity
+Data
+Bake the normals in world space
+Lock Camera and Layers
+Vertex group to control rotation
+Global
+Sun Brightness
+Optional custom node label
+Align to Normal
+Directory displayed in the file browser
+Deliver speed vector pass
+Enabled
+Frame player from Tweak Software
+Weighted result of strip is removed from the accumulated results
+A animation layer containing Actions referenced as NLA strips
+Key configuration that can be extended by addons, and is added to the active configuration when handling events
+Dominant
+Line Output
+Seam edge for UV unwrapping
+Options for this panel type
+Menu Widget Colors
+Main Worlds
+Shadowed
+11
+Atmosphere
+Create representation for obstacle simulation
+Estimated rotation matrix
+16
+Pose 
+Sun size
+NodeTree
+RGB
+2048
+Anaglyph
+Active Object
+Collection of curve splines
+Marker highlighting a portion of text in a Text datablock
+DopeSheet
+Magnetic effector weight
+Render face transparent and add color of face
+Previous Rotation
+Display Shapekeys
+Aggression
+en_US
+Color space to use for internal XYZ->RGB color conversion
+Numpad 7
+Sets the maximum number of physics step per game frame if graphics slows down the game, higher value allows physics to keep up with realtime
+Keying Sets All
+Boid
+Numpad 6
+Snap Element
+it_IT
+Include the name of the foreground sequence strip in image metadata
+Metaballs
+Active particle system being displayed
+Toggle between moving the viewpoint or moving the scene being viewed
+Use a Gaussian filter for anti-aliasing
+ChannelDriver Variables
+MetaBall
+Combined
+FFmpeg video codec #1
+Use Default Fade
+Numpad 3
+ZXY Rotation Order. Prone to Gimbal Lock
+Index to the specific setting if applicable
+Bake Mirror values
+Use vBVH
+Apply channel size as IK constraint if stretching is enabled
+Invert Zoom Direction
+Numpad 1
+Edge Sharp
+Unit Settings
+Stamp Frame
+Brush datablocks
+use global timestamp written by recording device
+Mapping
+Snap active onto target
+Rigid Body Joint
+Rate control: buffer size (kb)
+Scale factor along the Y for items in this (sub)layout
+RGBA
+Half
+Sets the number of rings rendered over the halo
+Turbulence
+Graph Editor instance has some ghost curves stored
+Halo
+No display
+Stiffness Scaling
+Use a custom falloff curve
+Contents Follow Opening Direction
+Off
+Seam
+Sculpt
+Sequences
+Stiff viscosity is a factor of normal viscosity
+Curve Guide
+Proportional Editing disabled
+Rotate Around Selection
+Key Maps
+Minimum
+Align newly added objects facing the active 3D View direction
+Tool Properties
+Amount of noise for the force strength
+Amount of ray samples. Higher values give smoother results and longer rendering times
+Numpad 8
+]
+Exclude specular pass from combined
+Stamp Scene
+Collection of grease pencil layers
+Choose Collision Type
+Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption)
+Particle system has been edited in particle mode
+Stroke conversion method
+Properties acting as inputs for this driver
+Point Cache
+Window Manager Event
+Collection of brushes
+Don't use a physics engine
+Material Override
+Temperature difference to ambient temperature
+State determining which controllers are displayed
+All Object Origins
+Uses extreme alpha
+Node Tree
+Before Current
+Array
+Collision settings for object in physics simulation
+Stretch To
+F-Curves for controlling the strip's influence and timing
+Field Order
+Hide Dot Files/Datablocks
+Loose
+Use Game Engine
+Onion Skinning (ghosting) settings for visualisation
+Draw dashed black-white edges
+Align handle selected color
+Minimum number of pixels between each gridline in 2D Viewports
+Sky
+Spring Frames
+Location of head end of the bone
+Active key configuration (preset)
+Width
+Action Group is selected
+Collection of Texture Nodes
+Collection of add-ons
+States which are being used by controllers
+Gravity or external force vector
+NLA Track is active
+Ogg
+Roll
+Grless
+Wheel Down
+Amount of friction during particle collision
+Search in all text datablocks, instead of only the active one
+View pivot location
+Draw image with RGB colors and alpha transparency
+Resolution
+Use the scene's active camera and layers in this view, rather than local layers
+Every point is effected by multiple springs
+Vertex
+Include the filename of the .blend file in image metadata
+Maximum distance error from contour to cells
+Output video in H.264 format
+Action displayed and edited in this space
+History
+Local View
+Stamp Text Color
+Translation
+IK Y Maximum
+File Select Parameters
+Shared Vertex
+Safe Margin
+Tip Size
+Edge color
+Negate the effect of the size vertex group
+Game engine controllers to process events, connecting sensor to actuators
+Triangle Mesh
+NLA Strip is played back in reverse order (only when timing is automatically determined)
+Scale Y
+H
+Main Lamps
+Approximate
+Controllers
+Deliver specular pass
+The number of old versions to maintain in the current directory, when manually saving
+Theme settings for the NLA Editor
+Nearest Marker
+Randomize star colors
+Theme settings for the Sequence Editor
+Index of refraction (higher values are denser)
+Local Location
+Default Key Configuration
+Show background image while looking to the right
+The space where the header is going to be used in
+Max number of vertices per polygon
+Quality of JPEG images, AVI Jpeg and SGI movies, Compression for PNG's
+Averaged Value
+Use a box filter for anti-aliasing
+Spin CCW
+Color to use for stamp text
+Wheel Invert Zoom
+Lock Camera to View
+New Interpolation Type
+Main data structure representing a .blend file and all its datablocks
+Calculate bone paths from heads
+Layer of vertex colors in a Mesh datablock
+Is this keymap item user defined (doesn't just replace a builtin item)
+Main Textures
+Enable soft body shape matching goal
+How many self collision iterations should be done. (higher is better quality but slower)
+Collection of scene bases
+Show right margin
+Ambient Occlusion
+Frame this control-point occurs on
+Snap to edges
+Turbulence effector weight
+Build record run time code index
+float
+Use Edges as springs
+Rings
+Color Ramp Elements
+Charge
+Thickness
+Zmask Layers
+The panel label, shows up in the panel header at the right of the triangle used to collapse the panel
+Spread
+Cluster Iterations
+Location
+Weight Paint
+15 - Theme Color Set
+space_data
+Vertex group to control kink
+If this is set, the menu gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_MT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_MT_hello"
+Path is being edited
+ShapeKey Editor
+AC3
+Set audio channels to 5.1 surround sound
+Minimum Size
+Path to a custom animation/frame sequence player
+Smoke inherits it's velocity from the emitter particle
+Display Lists
+Maximum number of frames on either side of the active frame to show (0 = show the 'first' available sketch on either side)
+Compress File
+Bezier U
+Displace
+Velocity Max
+Use Right Mouse Button for selection
+Box Backdrop Colors
+Exec Default
+3
+Path point is selected for editing
+Bone Group
+When calculating Bone Paths, use Head or Tips
+Project Individual Elements
+Parameters for IK solver
+Show the object origin center dot for all (selected and unselected) objects
+BLI BVH
+Realtime Updates
+Shutter
+How strongly the fluid tries to keep from clustering (factor of stiffness)
+Target
+Scrollbar
+Show controllers of all selected objects
+Instead of per brush radius, the radius is shared across brushes
+screen
+Use large mouse cursors when available
+Keymap is defined by the user
+Grease Pencil Stroke Point
+48 kHz
+Use the manipulator for rotation transformations
+Bullet
+Armature Bones
+Directory
+TimeCode Style
+Identifier
+Does full Sky texture render for diffuse energy
+Items in the keymap, linking an operator to an input event
+AvMinMax
+Multiply the current speed of the sequence with this number or remap current frame to this frame
+Apply force only in 2d
+MPEG
+Is this keymap item modified by the user
+Zoom in towards the mouse pointer's position in the 3D view, rather than the 2D window center
+How smoothly the boids land
+region
+Swedish (Svenska)
+Region in a subdivided screen area
+Add indirect light bouncing of surrounding objects
+Factor Radius
+Obstacle
+Color used for selected bones
+Line Numbers
+Draw edges after modifiers are applied
+Space Info
+Multicam Selector
+Reflection Exclude
+Weight of scale constraint for IK
+Node editor space data
+Link between nodes in a node tree
+Show the entire viewport in the display window, viewing more horizontally or vertically
+Pixel distance around the handles to accept mouse clicks
+Initial State
+Sum Values
+Channel Group
+Tools can use this to tag data, (initial state is undefined)
+The default directory to search for textures
+Lin error
+F-Curve is selected for editing
+Keying Sets
+Release confirms
+64
+Title for the file browser
+Sets the audio sample format
+Invert y Axis
+Include the name of the last marker in image metadata
+Collection of keyframe points
+3D View space data
+Vortex effector weight
+Object adds fluid to the simulation
+Use smoke velocity as texture data
+Maximum Radial Distance
+The axis to display the image on
+Keying set options
+Horizon Brightness
+Render Engine
+Display Particle
+Exclude AO pass from combined
+Lights user to display objects in solid draw mode
+Textbox Height
+Point coordinates
+Axis Angle (W+XYZ). Defines a rotation around some axis defined by 3D-Vector
+Text Editor
+Use display lists to speed up rendering by keeping geometry on the GPU
+Actuators
+Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)
+es_ES
+Auto Run Python Scripts
+Subtract
+Screen Editing
+Properties in the struct
+Set audio sampling rate to 96000 samples per second
+Scale to use when converting between blender units and dimensions
+Mouse/Trackpad Zoom
+X Ray
+Maximum distance of reflected rays (reflections further than this range fade to sky color or material color)
+True when this property is an output value from an RNA function
+False when F-Curve could not be evaluated in past, so should be skipped when evaluating
+Fresnel Factor
+Minimum for slider
+Use Goal
+Sets how the texture is extrapolated past its original bounds
+Minimum size of strands in pixels
+Points
+Motion Path
+Emission Color
+Global maximum shadow samples
+Path
+Action
+Sets the number of sub-flares
+Used State
+Update other affected window spaces automatically to reflect changes during interactive operations such as transform
+Filter Script
+Method to interpolate/smooth values between voxel cells
+Gives halo a texture
+Show markers belonging to the active action instead of Scene markers (Action and Shape Key Editors only)
+Divide
+Proportional Editing mode, allows transforms with distance fall-off
+Angular distortion between UV and 3D angles
+Random variation of damping
+Channels Selected
+plugin
+Spline IK
+The frame on which the timeline marker appears
+Snap to 1.0 frame/second intervals
+Handle 1 selected
+Free all image texture from memory after render, to save memory before compositing
+Method used for combining Active Action's result with result of NLA stack
+If enabled, stiffness can be scaled along a weight painted vertex group
+Invert z Axis
+Minimum regions size. Smaller regions will be deleted
+Display Mode
+Text bounding box for layout
+Onion Skinning
+Open
+User Add-Ons
+Output file format
+Size
+Backdrop X offset
+Active Pose Marker Index
+Text Marker
+Number of preprocessing passes to reduce overocclusion
+Modifiers affecting the shape of the F-Curve
+Wheel In
+Mesh Face
+Rotation Angle
+Path to a setting for use in a Keying Set
+Sync Markers with keyframe edits
+Whether to use minimum clipping value
+Main Actions
+Editing context being displayed
+Raytraced refraction settings for a Material datablock
+Enable image painting mode
+Hidden
+When adding objects from a 3D View menu, either align them to that view's direction or the world coordinates
+Only show and edit handles of selected keyframes
+Cinema 48fps 2048x1080
+Max Rate
+Envelope Head Radius
+Use old Octree structure
+Global maximum subdivision level
+Use this object's coordinate system instead of global coordinate system
+Viscosity
+Theme Properties
+Boolean Property
+UV Selection Mode
+Force the curve view to fit a defined boundary
+Objects
+Default (Default)
+Shade Down
+Grease Pencil Layers
+Current Keying Set index
+Shadow Exclude
+Root Size
+Rest Shade Key
+Framerate, expressed in frames per second
+Scrollback
+Overlay Lock
+Duplicate Text
+Russian (Русский)
+10 - Theme Color Set
+Collection of texture slots
+ID Materials
+I
+The distance from which particles are affected fully
+Action Pose Markers
+Clamp velocity to this maximum speed
+English (English)
+JPEG
+L
+Display only files with extensions in the image select window
+Theme Sequence Editor
+ID From
+All Scenes
+Make hairs longer or shorter
+Handle Vertex Select
+With displacement normalize to the distance, with ambient occlusion normalize without using material settings
+Physics
+ID
+Mesh Vertex Color Layer
+Use curve weights to influence the particle influence along the curve
+Cached location on path
+Motion
+Node tree being displayed and edited
+Tangent Shading
+Mesh Vertex Color
+B-Spline
+Based on distance/falloff it adds a portion of the entire path
+Theme settings for the Audio Window
+Displacement
+Coordinates of the second handle
+Rendering settings for a Scene datablock
+Radius of boids personal space on land (% of particle size)
+Live Edit
+The length of the contents of this strip before the handles are applied
+Display Armature
+Length Mode
+Display datablocks of active object
+SDL
+Collection of Nla Strips
+Amount the Active Action contributes to the result of the NLA stack
+Show only actuators connected to active states
+Vertex group for fine control over bending stiffness
+4 Channels
+Bake displacement
+Acceleration
+Angular Velocity
+Boid Rule
+Action Group
+Split quads predictably (0,1,2) (0,2,3)
+Struct definition this is derived from
+Include the current date in image metadata
+Action Group is expanded
+Draw title safe margins in preview
+Output image in DPX format
+Include visualization of Object-level Animation data (mostly Transforms)
+Proxy size 25%
+16 bit color channels
+The default directory to search for sounds
+Log
+Redraw all overlapping regions, minimal memory usage but more redraws
+International Fonts
+5.1 Surround
+Linear
+Settings that should be keyframed together
+Factor Repulsion
+Overlap Flip
+The active face for this mesh
+Turn on SB diagnose console prints
+Dome
+Brazilian Portuguese (Português do Brasil)
+Make hairs stand up
+Uses the vertex normal to specify the dimension of the halo
+Key maps configured as part of this configuration
+Active Space
+4
+Theme Text Editor
+Method to display/shade objects in the 3D View
+Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)
+Normalized Coordinates
+Glow
+Diffusion
+Enemy
+Co-ordinate system to cache vertices in
+Show state panel
+Show ghosts on keyframes
+Anti-Aliasing
+Zoom Axis
+Reactor Target Particle System
+First input for the effect strip
+Radians
+Free Nodes that are not used while compositing, to save memory
+Transform
+Free handle selected color
+Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)
+Button 10
+Amplitude
+Show Active States
+Space Nla Editor
+Vertex group to control length
+In text window, paste with middle mouse button instead of panning
+Collection of object constraints
+Transparent RGB pixels are multiplied by the alpha channel
+Calculates environment map at each rendering
+Deform
+Choose BW for saving greyscale images, RGB for saving red, green and blue channels, AND RGBA for saving red, green, blue + alpha channels
+Tweak Right
+44.1 kHz
+Include visualization of Texture related Animation data
+Set layer Visibility
+Deliver mist factor pass (0.0-1.0)
+Sort files by modification time
+Minimal # solver steps/frame
+Have recent edits been saved to disk
+Keying Set Paths to define settings that get keyframed together
+Pressure of tablet at point when drawing it
+Show background image while looking to the left
+Sharp
+Only include F-Curves with names containing search text
+Number of spaces to display tabs with
+Puff Volume
+Video bitrate(kb/s)
+Linear Stiffness
+Vertex Group Tangent
+Amount of dithering noise added to the rendered image to break up banding
+Absorption
+Find Wrap
+Enable hair dynamics using cloth simulation
+The type of the Sequencer view (sequencer, preview or both)
+Number Widget Colors
+File Extensions
+Theme Node Editor
+Object Duplicate
+Goal Maximum
+Size of element, use of components depends on element type
+Word Wrap
+Any
+More than one rendering engine is available
+Cached positions per frame
+Control key pressed
+Collection of armatures
+Gloss Anisotropy
+Tracking by taking the shortest path
+Spherical falloff
+Objects further than this are not visible to map
+Driver could not be evaluated in past, so should be skipped
+Insert Keyframes - Visual
+Rule Evaluation
+Negate the effect of the velocity vertex group
+The frame number to always use
+ca_AD
+Visibility
+Bone associated with this PoseBone
+Envelope Deform Distance
+Invoke Area
+Theme Info
+Current Keying Set index (negative for 'builtin' and positive for 'absolute')
+Black
+Lock editing of location in the interface
+Interface
+Auto Keying Enable
+Save luminance-chrominance-chrominance channels instead of RGB colors
+Left Ctrl
+Multiplier to adjust velocity passed to smoke
+Font size and resolution for display
+Extreme
+Show Controllers
+Render engine
+Render image to two fields per frame, for interlaced TV output
+To socket
+Activate TRUE level triggering (pulse mode)
+Temp. Diff.
+Expanded
+Target particle system
+Which part to snap onto the target
+local space unit length normal vector for this face
+Keying Set Name
+Python Console
+Show Hidden
+The region relative horizontal location of the mouse
+Nurb active V-lines
+Set position of selected color stop
+Fixed size UV coordinates array
+Reactor Target Object
+Node tree type to display and edit
+Display datablocks in current scene
+Color and Alpha
+Causes texture data to be duplicated with the object
+Item in a Key Map
+3D View region data
+Display face-assigned textures in solid view
+Disable simulation of linear motion along the Z axis
+Point of a curve used for a curve mapping
+Include visualization of Metaball related Animation data
+Structural Stiffness Maximum
+Factor Density
+Simple Deform
+The default color for textures that don't return RGB or when RGB to intensity is enabled
+Name of UV unwrapping layer
+Outputs
+Images
+Message
+Ray
+Theme Bone Color Set
+Redraw all overlapping regions, minimal memory usage but more redraws (for graphics drivers that do flipping)
+IK stiffness around the Y axis
+Edge spring stiffness when shorter than rest length
+Menu Backdrop Colors
+50%
+Heads
+Stereo Mode
+Soft body simulation settings for an object in the game engine
+Show Framerate and Profile
+Right Shift
+Direct conversion of frame numbers to seconds
+Log conversion reference whitepoint
+Radius
+Linear stiffness of the soft body links
+View3D Rotate Modal
+SMPTE
+Add
+Show framerate and profiling information while the game runs
+Degrees
+Gather Method
+Output
+Set audio sampling rate to 192000 samples per second
+End
+Include visualization of Material related Animation data
+Sets the layer as active for cloning
+Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing
+When bone doesn't have a parent, it receives cyclic offset effects
+Enable self collisions
+Property is registered as part of type registration
+Syntax Comment
+Draw Particles
+area
+Basis Matrix
+Active vertex color layer
+Image and UV editor space data
+Set metaball as negative one
+Collection
+JPEG Quality of proxies to build
+Zbuf
+Show the Z axis line in perspective view
+Tails
+Show Active Object
+Defines size of derivative offset used for calculating gradient and curl
+Color Set
+Integer
+Output image in bitmap format
+OpenAL
+Particle Systems
+Display the user preference datablocks
+Size of packed file in bytes
+Ukrainian (Український)
+Mono
+No proxy, full render
+Fullscreen
+Allow scaling of the bone for IK
+Creates viscosity for expanding fluid)
+J
+Blend mode for combining sun sky with world sky
+Global Undo
+Quicktime
+Draw frames rather than seconds
+Bake shading on the surface of selected objects to the active object
+Frame currently being displayed for this layer
+Never None
+alignment
+Bulgarian (Български)
+Light
+Maximal Spring length * Ball Size
+Emulates Middle Mouse with Alt+Left Mouse (doesn't work with Left Mouse Select option)
+Text datablocks
+Welding
+Heavy
+Quick Sketching
+Method used to determine color of F-Curve in Graph Editor
+Show UV Editor
+Cut hairs
+Expand
+Effect particles' location
+View Matrix
+Allow boids to climb goal objects
+Sequence
+Bone Name
+Seed of the noise
+Motion Path Cache Point
+Use modifier while in the edit mode
+Meshes
+For reactor systems, index of particle system on the target object
+Billboard
+Automatically set based on graphics card and driver
+Macro Operator
+DopeSheet Channel
+Render and combine multiple samples per pixel to prevent jagged edges
+Render Z-Transparent faces in this Layer (On top of Solid and Halos)
+Output image in uncompressed Targa format
+Paths
+Left Arrow
+Collection of spline bezirt points
+Layout
+Show Physics Visualization
+Number of bones in the subdivided stroke
+Vertex Group Clump Negate
+Negate the effect of the tangent vertex group
+Base type for IK solver parameters
+Active camera used in this view (when unlocked from the scene's active camera)
+Re-render and composite changed layer on 3D edits
+ISO 2
+Active Layer Index
+Esc
+Show Frame Number Indicator
+End Offset
+Use active Viewer Node output as backdrop for compositing nodes
+Blender command line animation playback - path to Blender 2.4
+Frequency
+Pivot around the median point of selected objects
+Blend vertex colors across face when vertices are shared
+Game engine logic brick to detect events
+Causes the image to repeat horizontally and vertically
+Bone location is set in local space
+User Preferences
+Show Operator
+Max Logic Steps
+Damping of the harmonic force
+Vertex of a simulated fluid mesh
+Graph Editor Generic
+18 - Theme Color Set
+Average Speed
+Console
+Total number points for the surface on the V direction
+Use the manipulator for scale transformations
+Disable
+5
+13 - Theme Color Set
+Vertex group to control field
+12
+Shared Location
+Transparent pixels are filled with sky color
+Atmosphere Turbidity
+Widget Style
+RNA function definition
+NLA Strip is not evaluated
+Recast Data
+4096
+Right Handle Selected
+Cyclic
+Color Ramp
+Self Collision Quality
+Index of active pose marker
+Vertex Group Density Negate
+Dome Mode
+Image and settings for display in the 3d View background
+Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist
+FPS
+Normals
+SIMD SVBVH
+Minimum distance between collision objects before collision response takes in
+Color balance gamma (midtones)
+Minimum distance for the field's fall-off
+Limit fluid objects to this group
+Load UI
+Factor Stiff Viscosity
+Draw preview using full resolution or different proxy resolutions
+Paint Lock
+Sets the number of samples used by the audio mixing buffer
+Source List
+Around Current Frame
+Scroll Handle
+Add light coming from the environment
+Color of the F-Curve in the Graph Editor
+Exclude indirect pass from combined
+Selection of IK solver for IK chain, current choice is 0 for Legacy, 1 for iTaSC
+Bias
+Text Input
+Pitch
+2D
+Braid
+Modifier name
+Use extra textures like normal or specular maps for GLSL rendering
+Stamp Marker
+ZXY Euler
+Function does not pass its self as an argument (becomes a class method in python)
+Sun Intensity
+Fit
+AO Exclude
+Integer Property
+Tube
+ZYX Rotation Order. Prone to Gimbal Lock
+Default paths for external files
+Solid
+Lock the same rotation/scaling pivot in all 3D Views
+Groups of F-Curves
+Display the object solid, with face-assigned textures
+Quadratic
+ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)
+Inaccurate, but faster and without noise
+Unique ID for this region
+Lock Y Axis
+Logic Nor
+Gaussian
+Euler
+Settings for filtering the channels shown in Animation Editors
+Invoke Region Channels
+Crop the rendered frame to the defined border size
+Limit Location
+Radius of the brush in pixels
+Automatically select also UVs sharing the same vertex as the ones being selected
+Title
+Histogram
+Display raw datablocks
+Bone deformation distance (for Envelope deform only)
+Forcefield based on the Lennard-Jones potential
+Action Group is locked
+XYZ Euler
+Outline Width
+Upper First
+Subdivide stroke in fixed number of bones
+Action Clip
+Use 16 bit floats instead of 32 bit floats per channel
+Stamp Camera
+Texture Nodes
+Falloff power (real gravitational falloff = 2)
+3D View near clipping distance
+Color Randomization
+Snap Peel Object
+Determine the amount of render threads used
+Amount
+F-Curve
+Zmask scene layers for solid faces
+Bone Group this pose channel belongs to (0=no group)
+Constraint's panel is expanded in UI
+Collection of Color Ramp Elements
+Grease Pencil
+Show controllers of active object
+Instead of per brush strength, the strength is shared across brushes
+Allow boids to move on land
+Negate the effect of the clump vertex group
+`
+Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis
+Highlight the current line
+Simplify Child Particles
+Lattice
+Timeline Markers
+Draw actual particles
+XYZ
+Collection of spaces
+Bake Mode
+Sub
+Enable Stereo environment
+F-Curve defining values of a period of time
+Rules are gone through top to bottom. Only the first rule that effect above fuzziness threshold is evaluated
+Constraint to stay within the image bounds while editing
+Only Selected Curve Keyframes
+Scroll Bar
+Theme settings for Font
+Allow Climbing
+Syntax Highlight
+ASCII
+Properties space data
+Lamp datablocks
+Pivot around bounding box center of selected object(s)
+Max Res
+Mouse Previous X Position
+Simplify the final stroke
+Frame is selected for editing in the DopeSheet
+OS Key
+Function is optionally registered as callback part of type registration
+Ease
+Renders halo as a star
+NLA Channels
+Use the speed vector pass to reduce AO samples in fast moving pixels. Higher values result in more aggressive sample reduction. Requires Vec pass enabled (for Raytrace Adaptive QMC)
+nl_NL
+Alt key pressed
+Limit movement around the Y axis
+Z Scale
+Actuator
+Motion Path for this element
+Slider Widget Colors
+Name of Vertex color layer
+Xnor
+Bone Group this pose channel belongs to
+Quad View Region
+Edge Split
+Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges
+Max Air Angular Velocity
+Use Bone Sketching
+Automatic keyframe insertion using active Keying Set only
+Colors
+Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)
+Show script files
+Cloth simulation settings for self collision and collision with other objects
+Object to use as the environment map's viewpoint location
+The interpolation type for this curve element
+Vertically Open
+Show the expanded in the user interface
+Emit Object Location
+Toggle Widget Colors
+Rotation
+Current Transformation orientation
+Total number points for the curve or surface in the U direction
+Active Particle System Index
+Material Physics
+Pull
+List Item Colors
+Show a small rotating 3D axis in the bottom left corner of the 3D View
+Add-Ons
+Render face with texture
+Tilt Interpolation
+K
+Collection of particle systems
+Text editor space data
+Zoom
+Goal minimum, vertex weights are scaled to match this range
+When deforming bone, multiply effects of Vertex Group weights with Envelope influence
+F-Curve Sample
+Radius of eraser 'brush'
+Finnish (Suomi)
+Turbulent noise driven by the global current frame
+Raytraced reflection settings for a Material datablock
+Convert effector force into air flow velocity
+True when the Shift key is held
+Audio Sample Format
+Bold
+Vertex colors for a face in a Mesh
+Cursor
+Mouse/Trackpad Pan
+Display Paths of poses within specified range
+Info space data
+Duplicate Armature
+Settings for Bullet soft body simulation
+Name of the theme
+Collection of scene objects
+B-Bone Display Z Width
+Zoom using up/down on the device (otherwise forward/backward)
+Enter Edit Mode automatically after adding a new object
+Apply gravitation to point movement
+Info on current cache status
+Cone
+Lock Z Rotation Axis
+GLSL Extra Textures
+Starts player in a new fullscreen display
+Named Group
+Samplerate
+Children expanded in the user interface
+Border
+Armatures active bone
+Active Path Index
+Texture Type
+Amount of clumping
+Style
+Collection of render layers
+Show Restriction Columns
+Soft Body
+Drag effector weight
+Layers visible in this 3D View
+Top
+Quality of the simulation in steps per frame. (higher is better quality but slower)
+The constraint is applied in Pose Space, the object transformation is ignored
+View Rotation
+Gravitation
+Cardinal
+Dolly
+8 bit greyscale binary data
+Chroma Vectorscope
+Active bone group for this pose
+Repulsion Factor
+Object Constraints
+Filter Text
+Vertex group to control tangent
+Default builtin key configuration
+Show folders
+Page Down
+Elements
+View3D Zoom Modal
+Show Actuators
+Deletes smoke from simulation
+Filter File Extensions
+Control point selection status
+Left Handle Selected
+Draw Stretch
+Align rotation with the snapping target
+Cloth
+Show the name of the view's direction in each 3D View
+Display Filter
+Object does not restitute collisions, like a ghost
+Particle Velocity
+Relative time of key over hair length
+6
+Threshold for drawing outlines on geometry edges
+Lighting
+MPEG-4
+Delete
+MPEG-2
+Curve Edit
+Distance of the physics area
+Boid Settings
+Pixel resolution of the rendered environment map
+Goal maximum, vertex group weights are scaled to match this range
+Vertex Group Roughness 2 Negate
+Manipulator Rotate
+Limits
+Current Frame
+Project to Self
+Sticky texture coordinate location
+Transition
+Duplicate Texture
+Mask
+Description of the Function's purpose
+Generate voxels from a sequence of image slices
+Theme settings for the Node Editor
+Automatic time snapping settings for transformations
+Banking
+Texture Plugin Directory
+Mass
+Mist settings for a World data-block
+Show column
+Tool Widget Colors
+Clip Alpha
+Retarget
+Drag component proportional to velocity
+Blocking
+Mirror Colors
+Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method)
+Bars Selected
+Use a minimum radial distance for the field's fall-off
+Edit Object
+Cineon
+Height
+Texture Factor
+Draw Wire
+Manipulate object centers only
+Custom color set to use
+Negate the effect of the density vertex group
+SL
+Enable Self Collision
+Correction
+Self Minimum Distance
+Keying set paths
+Invoke Region Preview
+Causes material data to be duplicated with the object
+Sample Distance
+Vertex Group Field
+Multiplier to make out-scattered light brighter or darker (non-physically correct)
+Object Selected
+Keyframe Selected
+Pose Bone
+Set sensor expanded in the user interface
+Theme Audio Window
+Strip Time
+Number of frames from start frame for influence to fade out
+Codec
+Speaker
+Image Generic
+3D Region
+Copy Scale
+Duplicate Surface
+Particle key for hair particle system
+Particle Edit
+Number of cone samples averaged for blurry refractions
+Keep from going through other boids
+Output image in DDS format
+Orig Height
+In Air
+Constraint was added in this proxy instance (i.e. did not belong to source Armature)
+OpenGL shading language shaders
+Render the stamp info text in the rendered image
+read only area of the face
+Exec Region Channels
+Smoke collides with every side
+Enable Collision
+The mouse button used for selection
+How strong a force must be to start effecting a boid on land
+Imperial
+Vertex Group Length
+SDL device - simple direct media layer, recommended for sequencer usage
+Pixel Aspect Y
+Shadow
+Show the active object's softbody point cache
+ZIP (lossless)
+Collection of Compositor Nodes
+Viewport Shading
+Mean red/green/blue scattering path length
+Ball inflating pressure
+Snap to nearest marker
+Vertical aspect ratio - for anamorphic or non-square pixel output
+Window Sliders
+Color ramp mapping a scalar value to a color
+Make hairs less puffy
+Active UV texture index
+Location of head end of the bone relative to its parent
+Display Texture
+Group Node
+Collection of meshes
+Continue
+Grease Pencil Smooth Stroke
+Set audio mixing buffer size to 4096 samples
+Transparent RGB and alpha pixels are unmodified
+Nearest Neighbor
+Gives a constant force along the force objects local Z axis
+Emit
+Bake the normals in tangent space
+Active Base
+Active UV texture
+Falloff Curve
+Sun intensity
+Collection of related sketches on a particular frame
+Vector Fonts
+Mesh Edit
+String Property
+Variables
+3D View Space
+Show the active object's particle point cache
+Cinema 24fps 2048x1080
+The default directory for rendering output, for new scenes
+Audio bitrate(kb/s)
+Font Size
+File
+Automatically converts all new tabs into spaces for new and loaded text files
+Search again from the start of the file when reaching the end
+Driver variable type
+Search term for filtering in the UI
+Show UV editing related properties
+Subdivision Surface
+Mipmaps
+Simplified Chinese (简体中文)
+Edge Length Text
+View2D
+Step Size
+All effector's weight
+GOP Size
+Bottom
+Color balance lift (shadows)
+True when this value can't be set to None
+The color of the lights specular highlight
+Free Run (Rec Date)
+How much the spring rest length can change after the elastic limit is crossed
+Nand
+Background Images
+Vertex Group Roughness 1 Negate
+Follow a boid or assigned object
+Collection of Shader Nodes
+Show Brush
+Save Preview Images
+Use Influence
+Add/Replace
+Enable direct editing of modifier control cage
+Overwrite characters when typing rather than inserting them
+Multitexture
+Full
+Modifier affecting the geometry data of an object
+Text to replace selected text with using the replace tool
+Particle Age
+Unique name used in the code and scripting
+Movie Strip
+Python Scripts Directory
+Global user preferences
+Proportional Size
+Location of the hair key in object space
+Window Manager
+Selectable
+Diffuse subsurface scattering settings for a Material datablock
+Air Personal Space
+Which axis to use for offset
+Sound
+Include Animation Data blocks with no NLA data. (NLA Editor only)
+Tree Type
+The index of particle system on the target object
+Noise algorithm - Voronoi F1-F2
+Autosplit Output
+Type of transition used to fade mist
+Logic Nand
+Enable this OpenGL light in solid draw mode
+Explode
+Tilt CW
+ID-Block
+Diffusion factor, the strength of the blurring effect
+Rate control: min rate(kb/s)
+Alter spring length to shrink/blow up (unit %) 0 to disable
+Object is made a particle system to display particles generated by a fluidsim domain object
+Alternate script path, matching the default layout with subdirs: startup, addons & modules (requires restart)
+channels
+Head Select
+Nearest Frame
+WPaint Auto-Normalize
+View3D Gesture Circle
+Active index in render layer array
+True when the Cmd key is held
+When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used
+Poly
+Name of the key map
+Roll bones to face the view
+Cycle the animated time within the action start & end
+Metaball Edit
+Use anti-aliasing for the 3D view (may impact redraw performance)
+Key Configuration
+NLA editor space data
+Sounds
+Noise formula used for turbulence
+Show Thumbnails
+Output video in AVI Raw format
+Shape Keys
+Cloth simulation settings for an object
+Transparency along the width of the strand
+Name of UV layer to override
+Custom animation player executable path
+Spring Vertex Group
+Luma Waveform
+Goal Damping
+French (Française)
+tool_settings
+3D Cursor
+Collection of lattices
+Display
+Center of mass
+The type of radius interpolation for Bezier curves
+Global approximate AA and SSS quality factor
+Type of data to take texture from
+Build
+Logic Xor
+Backdrop zoom factor
+Collection of worlds
+Python addons to be loaded automatically
+Proxy size 50%
+Intensity of the mist effect
+UV Editor
+Opacity
+JPEG 2000
+ID Type
+Wires
+Texture Face
+The default directory to search for sequence plugins
+Physics settings for a Material datablock
+Size of the turbulence
+Plastic
+Viscoelastic Springs
+Keyframe Insert Needed
+Threads Mode
+Exclude environment pass from combined
+Display an additional 'summary' line. (DopeSheet Editors only)
+Blend factor with sky
+BMP
+Obstacle simulation
+Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled
+7
+Enable naive vertex ball self collision
+Text Character Format
+Particle System
+Active section of the user preferences shown in the user interface
+Outliner
+Don't use any brush
+Pulldown Widget Colors
+Duplicate Lamp
+Spring rest length (factor of particle radius)
+Softens the edges of halos at intersections with other geometry
+None
+ko_KR
+Only Matching F-Curves
+Active Particle Target
+TIFF
+Keyboard
+Strand settings for a Material datablock
+"
+Material Index
+Targa Raw
+Name that will be used in exported files when format supports such feature
+F-Curve is not evaluated
+Texture Collection Rate
+Blend
+Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy
+rect
+08 - Theme Color Set
+Sharp falloff
+Proxy Local
+Repulsion Distance
+Method used for combining strip's result with accumulated result
+Particle speed (absolute magnitude of velocity) mapped as 0.0-1.0 intensity
+Syntax Numbers
+Images get saved in 8 bits grayscale (only PNG, JPEG, TGA, TIF)
+Global Space
+Save the z-depth per pixel (32 bit unsigned int z-buffer)
+Curving of the noodle
+View Type
+Children Expanded
+Shape
+Background Image
+Dash
+Pass
+Snap to Pixels
+Engine
+Vertex Select
+Specular Exclude
+Color 2
+Brush strength
+Control point weight values
+Maximum memory usage in megabytes (0 means unlimited)
+Pivot around each object's own origin
+Island
+Softbody goal weight
+Exclude shadow pass from combined
+Method for driving added turbulent noise
+Sampled colors along line
+Offsets the number of the frame to use in the animation
+Maximum angular velocity on land (relative to 180 degrees)
+Start Frame
+Middle Mouse Paste
+Edge Seam
+Display UV coordinates from 0.0 to 1.0 rather than in pixels
+Find Text
+Inverse Gamma
+Smooth hairs
+Graphics driver and operating system settings
+How much density effects smoke motion, higher value results in faster rising smoke
+passes
+Boid rule name
+Maximum number of recently opened files to remember
+Path to property setting
+Level of detail in the added turbulent noise
+Screen
+Billboard Normal UV
+Selects the type of physical representation
+Clip End
+Creates a force along a curve object
+Time delay in 1/10 seconds before automatically opening top level menus
+Autosplit output at 2GB boundary
+Resolution Y
+Artificial buoyancy force in negative gravity direction based on pressure differences inside the fluid
+Gamma
+Light Cache
+Offset
+Voronoi F2-F1
+Hair keys are in global coordinate space
+Structs
+Particle system name
+Don't adjust roll
+Bevel
+UI Layout
+Movie Format
+Fast but not so effective compression
+Use linear workflow - gamma corrected imaging pipeline
+Delta
+Gravity
+Mist uses linear progression
+BSpline
+Type of element to snap to
+Set audio mixing buffer size to 32768 samples
+Show the Y axis line in perspective view
+Action End Frame
+Settings for input devices
+Joystick
+Window manager datablocks
+Left Handle Type
+Points U
+bl_description
+Collection of mesh edges
+Clip objects based on what's visible in other side views
+Object Grouped
+Backscattered Light
+Active grease pencil layer
+Animated Influence
+Atmosphere Inscatter
+Color of emitted light
+Lock Location
+Active Vertex Color Layer
+Spaces
+Properties of particle editing mode
+Area height
+Material nodes
+Collection of armature bones
+Resolution U
+Click
+Filter Files
+Display general information
+Bone Groups
+Overlay
+Muted
+Movie
+Auto Clamped
+Individual Origins
+Overlap
+Custom
+Particles
+Use Max
+Window
+File browser space data
+AVI JPEG
+Friction Coefficients
+Object base selection state
+Bone Pose
+Sequence strip in the sequence editor
+Display Background Images
+Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit)
+User defined layer of floating pointer number values
+96 kHz
+Occlude
+Images are rendered in Image Editor
+States
+Saturation
+Location of this character in the text data (only for text curves)
+Users
+Scene Objects
+Goal Stiffness
+Audio Codec
+Collection of objects
+Type of NLA Strip
+Minimum distance to the camera for stars
+Main Scenes
+Clips to image size and sets exterior pixels as transparent
+Interpolation method to use for segment of the curve from this Keyframe until the next Keyframe
+Radius from the shaded sample to look for points within
+Layer of texture faces in a Mesh datablock
+Tangent
+Stamp Time
+Comb hairs
+24-bit Signed
+Show Handles
+Alpha
+Difference
+The frequency of the offset (1/total length)
+Layer Membership
+Render layer
+ro_RO
+Vector Coordinates
+Spring force
+Flare Boost
+Scopes
+Description of the item's purpose
+Camera Parent Lock
+Invert the axis of mouse movement for zooming
+Socket name
+M
+Enable diffuse subsurface scatting effects in a material
+Color Factor
+Noise algorithm - Cell Noise: Square cell tessallation
+For PoseBone paths, use the bone head location when calculating this path
+Max Land Speed
+Show linked objects to sensor/actuator
+Edit drivers
+F-Curve Modifier is the one being edited 
+Channel Matrix
+Has Ghost Curves
+Threshold for adaptive sampling (if a sample contributes less than this amount [as a percentage], sampling is stopped)
+Selects which domain border will be treated as collision object
+Object that defines custom draw type for this bone
+Still Frame Only
+Invert tilt axis
+The name of the active key configuration
+Apply sun effect on atmosphere
+Spacebar
+Limit effectors to this group
+Keep paths from intersecting the emitter
+Input or output socket of a node
+Transform Channel
+Storage of a macro operator being executed, or registered after execution
+Sets the number of points on the star shaped halo
+Display the object's local bounding boxes only
+Goal (vertex target position) spring stiffness
+Boolean
+Cyclic U
+Cinema 24fps 4096x2160
+Images are saved with RGB and Alpha data (if supported)
+Cyclic V
+Indirect
+Show Points
+Speed
+Copy Location
+GLSL Lights
+resolution_x
+All available keying sets
+Specular Color
+Convert to logarithmic color space
+Show keyframes for active Object and/or its selected bones only
+Use Visual keying automatically for constrained objects
+Game Property
+Merged Region Size
+Material Halo
+Flare Seed
+No Gimbal Lock (default)
+Bending Const
+Null device - there will be no audio output
+Main Fonts
+Sensor
+Output image in Cineon format
+Set audio sample format to 64 bit float
+Whether to use maximum clipping value
+Display units in pairs
+Form factor scales the inertia tensor
+Filter Images
+Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard
+Draw UV edges anti-aliased
+Search string is sensitive to uppercase and lowercase letters
+Region Text Titles
+Flow Settings
+Texture Slot
+Enable debug visualization for obstacle simulation
+Wrinkle coefficient. (higher = less smaller but more big wrinkles)
+Action to take for gaps past the Active Action's range (when evaluating with NLA)
+Spring rest length is a factor of 2 * particle size
+Mist uses quadratic progression
+Base
+Enter Edit Mode
+Widget Label Style
+For Zmask, only render what is behind solid z values instead of in front
+Face Angle Text
+8
+Face Dot Size
+Grow
+Strips
+Vertex group to control roughness end
+Texture Slots
+Snap UVs to pixel locations while editing
+Border Minimum X
+Value
+Button5 Mouse
+Roll CCW
+Deprecation Warnings
+Source List Title
+Collection of fonts
+Effector weights for physics simulation
+2
+Input line for the interactive console
+;
+Soft body
+Display Lamp
+Tail Select
+Rotation in Quaternions
+Main MetaBall
+Right Alt
+Waveform Mode
+Audio samplerate(samples/s)
+Random
+Harmonic
+hr_HR
+Themes
+Texture scatting blend factor
+Selected File
+Cache AO results in pixels and interpolate over neighbouring pixels for speedup
+double
+Negate
+Mute this shape key
+Fgon
+RVO (rays)
+External file packed into the .blend file
+Causes text data to be duplicated with the object
+Include visualization of Speaker related Animation data
+Zoom factor
+Tweak Select
+Shape Match
+Spherical forcefield based on the charge of particles, only influences other charge force fields
+Active Boid Rule
+Active index in bone groups array
+IK stiffness around the X axis
+Go to assigned object or loudest assigned signal source
+Wait Timer (ms)
+The region relative vertical location of the mouse
+Mouse/Trackpad Rotate
+02 - Theme Color Set
+Show Control Curves
+Time taken in frames between shutter open and close
+Textured Solid
+Tail
+Lift Force
+The type of event, only applies to some
+Targets
+Main Texts
+Draw Axes
+Space data type
+Subsurface Scattering
+Mesh Vertex
+Max Slope
+Specular Intensity
+Smoke collision settings
+Cubic
+Set all state bits
+Action to take for gaps past the strip extents
+Neutral
+UV mapping, texturing and game engine data for a face
+Minimum value for clipping
+zh_CN
+Wheel Scroll Lines
+Shadow color in grey value
+The constraint is applied relative to the world coordinate system
+Icon File
+Theme Console
+Step Calculation
+Amount the strip contributes to the current result
+Shape Key Bezier Point
+Smoke doesn't collide with top and bottom sides
+Fastest and gives the most noise
+Source of input values for driver variables
+Show Keyframe Numbers
+Image opacity to blend the image against the background color
+Outline
+window_manager
+DDS
+Show key map event and property details in the user interface
+Bake ambient occlusion
+Long List
+Manual
+Kink
+Display Metaball
+View Location
+Radio Widget Colors
+Weights
+Cache of the worldspace positions of an element over a frame range
+Theme settings for the Text Editor
+Number of frames for Blending In/Out is automatically determined from overlapping strips
+Collection of Driver F-Curves
+Use SIMD QBVH
+UV/Image Editor
+Use degrees for measuring rotation
+Resolution of the voxel grid
+Physics Gravity
+bl_idname
+Name of the key configuration
+Agent Radius
+Keyed particles target is valid
+Use force fields when growing hair
+Point in the lattice grid
+The amplitude of the offset
+End Frame
+Lets halo receive light and shadows from external objects
+Pivot
+Maximum walkable slope angle in degrees
+Permeability
+User defined floating point number value in a float properties layer
+Render Result
+Objects nearer than this are not visible to map
+Pivot around active object
+Operator Node
+Local With Parent
+Blender RNA structure definitions
+Radius of bounding sphere and material physics
+Bezier
+Blend Type
+Original Perlin
+Active UV Texture
+Active Object constraint
+Armature-Relative Head
+F-Curve's settings cannot be edited
+7.1 Surround
+Fluid Mesh Vertex
+Long Key
+Do not show any ghosts
+Frame for absolute keys
+Wav
+Preview
+[
+ObData
+Emulate Numpad
+Theme settings for the Timeline
+Cell Size
+Clamp velocity to this minimum speed (except when totally still)
+Specify old mapping value in frames
+Type of texture data to display and edit
+Show ghosts for the specified frame range
+Radius for bevelling
+Maximal # solver steps/frame
+Copy Rotation
+07 - Theme Color Set
+Use object/global coordinates for texture
+If set to True, the panel shows a header, which contains a clickable arrow to collapse the panel and the label (see bl_label)
+Sequence Element
+Use rule when boid is flying
+Simplify Shadow Samples
+Deliver indirect lighting pass
+Particle Key
+Time since last step in seconds
+Properties
+Y Scale
+Minimum Radial Distance
+Sampled Points
+Theme Logic Editor
+Use Stars
+Manipulator Translate
+Brush steps
+Active Pose Marker
+F-Modifier
+N
+True when the Alt/Option key is held
+Decimate
+Use multi-sampled 3D scene motion blur
+Type of active data to display and edit
+Permanent deform
+Onion Skinning Settings
+Mode of automatic keyframe insertion for Objects and Bones
+Theme settings for bone color sets
+Scopes for statistical view of an image
+Push
+Show Seconds
+Logic Or
+Buffer Resolution
+Create a toon outline around the edges of geometry
+Regions
+Damped Track
+Active Bone Group Index
+Automatically select acceleration structure
+Specify a collision bounds type other than the default
+Auto-Clamped handle color
+Vertex Group Roughness End
+Sets the maximum number of logic frame per game frame if graphics slows down the game, higher value allows better synchronization with physics
+Control Point
+Particle count
+Turntable
+Use Weight Color Range
+Octree
+Environment Exclude
+Fuzziness while on collision, high values make collision handling faster but less stable
+Tweak
+Marker
+Shadeless
+Align handle color
+Mist
+Scene Render Layer
+Sequence editing data for a Scene datablock
+Structural Stiffness Vertex Group
+Meta Stack
+Duplicate F-Curve
+Show sound files
+Render layer name
+Index of active particle system slot
+Roll bone to original joint plane offset
+Filter Fonts
+Material Subsurface Scattering
+Tip
+Invalid
+Show Cache
+Delay
+Blend factor for SSS colors
+Fluid Group
+Causes F-curve data to be duplicated with the object
+Stationary object
+el_GR
+Compression method to be used
+Speaker datablocks
+B-Bone Ease In
+Relative Paths
+Mesh Int Property Layer
+Enable smoke to disappear over time
+Double Click Timeout
+Cell Noise
+Particle system has multiple point caches
+Human readable name
+The object that has the target particle system (empty if same object)
+Maximum acceleration on land (relative to maximum speed)
+Legacy
+Clip alpha below this threshold in the 3D textured view
+Display a preset button with the operators settings
+Force gets absorbed by collision objects
+9
+Noise method which is used for creating the high resolution
+Manipulator
+Select UVs that are at the same location and share a mesh vertex
+Shadow offset in pixels
+Bake directly from multires object
+Insert
+Wind effector weight
+DopeSheet Editor
+Entire Array
+Use smoke heat as texture data. Values from -2.0 to 2.0 are used
+Sequence Color Balance
+Disallow movement around the X axis
+Scenes
+Active KeyConfig
+Distance between two bones or objects
+Rate control: max rate(kb/s)
+Active file in the file browser
+Limit collisions to this group
+Nurbs weight
+Outline Selected
+Extrapolate the curve or extend it horizontally
+Right Handle
+Collection of mesh vertices
+Smooth the final stroke
+Current Transform Orientation
+F-Curve live filtering string
+Softness of the 'soft' falloff option
+Selection Mode
+Proportional Editing
+Collection of keying set paths
+Build 25% proxy resolution
+DBVT culling
+Armature Edit
+Show Datablock Filters
+A valid edit mode exists
+World Mist
+Default Value
+Full Screen
+Text in the line
+Quality
+A container referencing an existing Action
+Layer name
+Auto Start
+Visualization
+Show text files
+Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion)
+Snap Align Rotation
+Angle of Rotation for Axis-Angle rotation representation
+192 kHz
+From socket
+Nurb active U-lines
+Constraints that act on this PoseChannel
+Cyclic Strip Time
+Space Outliner
+Constraint has valid settings and can be evaluated
+Debug
+Pose Bones
+Show image files
+Goal maximum, vertex weights are scaled to match this range
+Puff
+Right Handle Type
+Include the name of the active cameras lens in image metadata
+Sky Color Space
+Include visualization of Armature related Animation data
+Character Index
+Pin (vertex target position) spring stiffness
+Open source frame player: http://djv.sourceforge.net
+Grab Pointer
+Bone is not able to be transformed when in Edit Mode
+Show linked objects to the controller
+Blend Distance
+Edited
+The mode used to apply the texture
+Locked Track
+File Browser
+Vertex weight group, to blend with basis shape
+The type of keyframe (for visual purposes only
+Obstacle Radius
+Drawing method used by the window manager
+Active Particle Target Index
+Front
+Enable starfield generation
+Particle datablocks
+Show an outline highlight around selected objects in non-wireframe views
+Zooms in and out based on vertical mouse movement
+Calculate sub-surface scattering in materials rendering
+Parent this node is attached to
+ar_EG
+Include the render frame as HH:MM:SS.FF in image metadata
+Line of text in a Text datablock
+Detail mesh sample spacing
+Active Theme Area
+Theme Widget Color Set
+Boid height relative to particle size
+Using 1/x 
+Scene keying sets
+Show Sliders
+All Z
+Environment Color
+Position
+Buffersize
+Adapt To Speed
+Or
+World datablocks
+Effect Strip
+Group of ID properties
+Proxy size 75%
+Vertex Paint
+Hair Dynamics
+Stroke Points
+NLA Track is locked
+Which mesh elements selection works on
+Weight of rotation constraint for IK
+Always refresh image on frame changes
+Use horizon and zenith color for diffuse energy
+Extra margin around object for collision detection, small amount required for stability
+Collection of vertex groups
+Coordinates of the first handle
+Sky Blend Mode
+Mesh Edge
+Adjust simulation speed
+Bounding box of this object represents the computational domain of the fluid simulation
+Color balance gain (highlights)
+Normal Space
+Layers
+Spin CW
+Mesh Float Property Layer
+Buffer Resolution - decrease it to increase speed
+12 bit color channels
+Space Graph Editor
+Directory Path
+False when this property is an optional argument in an RNA function
+Framing Types
+Display Paths of poses within a fixed number of frames around the current frame
+Last selected point
+Cropping parameters for a sequence strip
+Min Air Speed
+Wavelet
+Color used for the surface of bones
+Window Managers
+Occlude objects with the environment color as they are further away
+Attenuation falloff strength, the higher, the less influence distant objects have
+Driven Selected
+Surface Edit
+Causes metaball data to be duplicated with the object
+Main Curves
+Japanese (日本語)
+Vertex Group Field Negate
+Collection of uv textures
+Enable simplification of scene for quicker preview renders
+String
+Randomized
+Retarget template bone chain to stroke
+Use the manipulator for movement transformations
+Command line prompt language
+How the rules in the list are evaluated
+Color of texture overlay
+Text Box
+Modifier for values of F-Curve
+Specify the number of cluster iterations
+Mass of the object
+React to force field physics settings in materials
+The window relative vertical location of the mouse
+YCbCr (ITU 709)
+Linear viscosity
+8x
+Nothing
+IK Z Limit
+Sensors
+Child Seed
+Tweak Middle
+Object represents a volume of fluid in the simulation
+Property is editable through RNA
+Theme settings for the Console
+Datablock from which the edited datablock is linked
+Particle
+Solo
+Mark controller for execution before all non-marked controllers (good for startup scripts)
+FFMpeg audio codec to use
+ZTransp
+Location (Object Space)
+IK Z Lock
+Display size for normals in the 3D view
+Use a tent filter for anti-aliasing
+Original IK solver
+Use velocities for automagic step sizes
+Multiplier
+Constraint Target
+Draw Repeated
+For RGB curves, the color that white is mapped to
+Noise algorithm - Voronoi F1: Returns distance to the closest feature point
+IK Y Minimum
+Pin Stiffness
+Cache Info
+No Ghosts
+Duplicate Material
+Nurbs order in the V direction (For surfaces only), Higher values let points influence a greater area
+Spanish (Español)
+Sets the dimension of the halo
+Vertex in a Mesh datablock
+Line Numbers Background
+Shadow Size
+Depth
+Rest Density
+Frame Server
+alert
+Meta Element
+Show actuators of all selected objects
+Calculate environment maps while rendering
+Motion Path Settings
+Interlaced
+Space type
+Display the operator log
+Show background image in front view
+Simple
+Storage of a sub operator in a macro after it has been added
+Collision Bounds
+Maximum value for clipping
+Transparency
+Armature-Relative Tail
+Display in the info window and support the redo toolbar panel
+FFMpeg codec to use
+Show frame numbers on Motion Paths
+Maximum allowed number of light inter-refractions
+Use a third buffer for minimal redraws at the cost of more memory
+Game engine logic brick to process events, connecting sensors to actuators
+Layer in multilayer image
+Depth Cutoff
+Mesh Edges
+Max Edge Length
+The number of lines scrolled at a time with the mouse wheel
+Root Texture Coordinates
+Tag Seam
+Visibility status
+Birth Time
+Mini Axis Brightness
+Environment
+Accuracy
+Driven
+Air Damping
+Use Vertex Buffer Objects (or Vertex Arrays, if unsupported) for viewport rendering
+Normal
+Keys
+The axis icon's size
+Spring Force
+Brushes
+Drag
+Emulate 3 Button Mouse
+Sculpt/Paint Overlay Color
+Collection of keymap items
+Shadow Y Offset
+Fuzzy
+Comb
+Theme settings for the 3D View
+End frame of the stored range
+Grid Subdivisions
+Layers bone exists in
+Base type for datablocks, defining a unique name, linking from other libraries and garbage collection
+Numpad 5
+face area
+Clip Start
+Numpad 2
+Tweak Action
+Numpad 0
+Use this files path when library linked into another file
+GL Texture Limit
+Only keyframes of selected F-Curves are visible and editable
+Numpad 9
+Crease
+Filter
+Minimum angles for IK Limit
+Scatter contribution factor
+Bones which are children of this bone
+Main Particle Settings
+Collection of particle settings
+Use modifier during rendering
+Numpad /
+Numpad .
+05 - Theme Color Set
+Read Only
+Include visualization of Particle related Animation data
+Numpad *
+Bone is not visible when in Edit Mode
+Width Fade
+Amount of rotation around velocity vector on turns
+Czech (Český)
+Display datablocks in all scenes
+Turbulent noise driven by the particle's age between birth and death
+Aerodynamics Type
+Best quality
+Use effector/global coordinates for turbulence
+Target particle systems
+Min Rate
+Distance to keep particles away from the emitter
+Type of information to display
+Limit movement around the Z axis
+NLA stack is evaluated when evaluating this block
+Apply puff to unselected end-points, (helps maintain hair volume when puffing root)
+Fgon edge
+Perspective
+Bone rotation around head-tail axis
+Pan/Zoom
+Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking
+No Auto-Snap
+Active Texture Face
+Node Backdrop
+Count
+Amount of influence F-Curve Modifier will have when not fading in/out
+Collection of points that make up this poly or nurbs spline
+Enable All Codecs
+Auto Blend In/Out
+Show Python Tooltips
+Show menus in the header
+Action datablocks
+Edit texture nodes from World
+Cross
+Particle target name
+Frame Map Old
+Collection of channel driver Variables
+Lower First
+Stamp Render Time
+Groups of the bones
+Vertex Group Velocity
+Cine-Flat 48fps 1998x1080
+Snap
+Extreme Alpha
+2x
+Group datablocks
+Overall sensitivity of the 3D Mouse
+Images are rendered in full Screen
+Activity culling is enabled
+2D cursor location for this view
+Metaball types
+F
+Show Linked to Actuator
+Square (HS + V)
+Node Groups
+Name Property
+Dither Intensity
+Reconstruction filter used for combining anti-aliasing samples
+Minimal
+Active Face
+Scripts
+Scale factor along the X for items in this (sub)layout
+Image Axis
+Orig Width
+Pose Head Position
+Cursor Y-Value
+Property is optionally registered as part of type registration
+IK stiffness around the Z axis
+NLA Tracks
+Constrain to Image Bounds
+Arrangement of the panels
+Length of second Bezier Handle (for B-Bones only)
+Median
+Indirect Exclude
+AO
+Node in a node tree
+Cast
+Save cache files to disk (.blend file must be saved first)
+Simplify AO and SSS
+Use key times
+de_DE
+Property has been dynamically created at runtime
+Ball Size
+Display sequence datablocks
+Read-only matrix calculated from the roll (armature space)
+Noise algorithm - Improved Perlin: Smooth interpolated noise
+Automatically start game at load time
+Generate point density from a particle system
+How much of effector force gets lost during collision with this object (in percent)
+Deliver AO pass
+Group that included Object should be a member of
+Cell Height
+Shear Stiffness
+Material Volume
+Maximum number of lines to store for the console buffer
+Include visualization of Mesh related Animation data
+Object Non-modal
+Maximum acceleration in air (relative to maximum speed)
+Pin ID
+Radar
+Render color of textured face as color
+Parts Y
+Parts X
+Collection of F-Curve Modifiers
+Verts Per Poly
+Lock to Cursor
+Theme Image Editor
+Graph Editor 2D-Value cursor - Y-Value component
+Automatically merge vertices moved to the same location
+Stencil
+Lock strip so that it can't be transformed
+Vertex Group Rotation
+Djv
+Use a quadratic filter for anti-aliasing
+Calculates environment map only once
+Node Links
+The number of subdivisions between grid lines
+Filter Folder
+use images in the order as they are recorded
+Collection of libraries
+Use selection as the pivot point
+Auto Snap
+The original matrix of this object before it was duplicated
+The unit system to use for button display
+Limit selection to visible (clipped with depth buffer)
+Type of field
+float_array
+Root falloff
+The quality of the anisotropic filtering (values greater than 1.0 enable anisotropic filtering)
+Dodge
+Active Vertex Group Index
+Method used for determining what ghosts get drawn
+Proportional Editing Objects
+Parent
+Particle dupliobject name
+Theme Widget State Color
+Tilt CCW
+Mirror Intensity
+Object
+Include visualization of Lamp related Animation data
+Object Location
+select_end
+FrameCycler
+Joint
+Backdrop X
+Backdrop Y
+Use Instances
+Y Rotation
+Nor
+Addon
+Anti-Aliasing Samples
+frames_skipped
+Stamp Lens
+Make hairs more puffy
+Offsets image horizontally from the view center
+Negate the effect of the roughness 2 vertex group
+Invoke Screen
+A square showing Hue/Saturation, with Value slider
+NLA Track
+Outer Thickness
+Format of Time Codes displayed when not displaying timing in terms of frames
+Display Node
+Boid will fight this times stronger enemy
+Custom Color
+P
+Negate the effect of the rotation vertex group
+Select Tail
+Settings for boid physics
+Options for this operator type
+Mouse Y Position
+Input properties of an Operator
+Fixed
+Current windowmanager and data context
+Collection of actions
+Tab Width
+Theme 3D View
+Render
+Auto Keyframe Insert Available
+Grid Scale
+Number of undo steps available (smaller values conserve memory)
+Show background image in bottom view
+Theme Graph Editor
+Surface
+Flash
+Collision
+Grid Lines
+Pre Roll
+Strand
+The transformation of the target bone is evaluated relative its local coordinate system, with the parent transformation added
+Disables non-planer quads being triangulated
+Particle Brush
+Smoke doesn't collide with any border
+Ghost frames on either side of frame
+Frame
+Select
+ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil)
+Index
+Functions
+03 - Theme Color Set
+Built-In Function
+Display objects name and frame number in 3D view
+Custom text to appear in the stamp note
+Cameras
+Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point
+Estimated scale matrix
+Overall stiffness of structure
+State
+Camera
+Distance between key frames
+Image Painting
+Object is made a fluid control mesh, which influences the fluid
+Draw image with RGB colors
+Build 100% proxy resolution
+Space Type
+Transformation
+Method of calculating the steps through the volume
+Material slot name
+Number of frames between cached frames
+Repulsion is a factor of stiffness
+Edge spring friction
+Face Area Text
+Frame Map New
+Media Play/Pause
+Mux Rate
+Show background image in all views
+Slider Max
+Every Point
+Stub RNA type used for pointers to unknown or internal data
+Number of indirect diffuse light bounces
+Clip Min X
+Clip Min Y
+Link
+Record animation to fcurves
+Object removes fluid from the simulation
+The number of times this object is repeated with respect to other objects
+Line
+Method used to define which Group-name to use
+Use Material Force Field
+Multi constraint, stateful IK solver
+Texture nodes
+Locked
+Filebrowser Parameter
+Path to an image editor
+Weights for the vertex groups this point is member of
+Insert keyframes based on 'visual transforms'
+Armatures
+Nabla
+Mesh String Property
+Collection of action groups
+Keep path lengths constant
+The type of tilt interpolation for 3D, Bezier curves
+Creates a force that dampens motion
+Disable simulation of linear motion along the Y axis
+Green
+Layer is selected for editing in the DopeSheet
+Voronoi F2
+Voronoi F3
+Active F-Curve Modifier
+Cycles
+Margin
+Voronoi F4
+Theme settings for the Image Editor
+Face Dot Selected
+Damping of cloth velocity. (higher = more smooth, less jiggling)
+GLSL Color Management
+Prompt
+Length of first Bezier Handle (for B-Bones only)
+Theme settings for style sets
+Ctrl
+Show intermediate values for the driver calculations to allow debugging of drivers
+Apply this and all preceding deformation modifiers on splines' points rather than on filled curve/surface
+Vertex indices
+Lens angle (mm) in perspective view
+Back
+German (Deutsch)
+Color of light scattered out of the volume (does not affect transmission)
+Build free run time code index
+Extrapolation
+Theme settings for Info
+Collection of metaball elements
+Use face normal to rotate object, so that it points away from the surface
+Lens
+Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction
+Particle Dupliobject Weight
+Use textures for drawing international fonts
+Use light for face
+The edge flag to tag when selecting the shortest path
+Vinterlace
+Cycle the images in the movie
+Display Z Axis
+Reflectivity
+Window Draw Method
+Set audio sampling rate to 44100 samples per second
+Causes particle systems to be duplicated with the object
+Scripts Window
+The space where the panel is going to be used in
+SMPTE (Compact)
+Automatically merge nearby keyframes
+Fast in high-contrast areas
+YCC
+Deliver object index pass
+Bake shadows
+Continuous Grab
+Alive State
+Input
+Adaptive
+Single texture face materials
+Color Ramp Element
+Hue
+Error tolerance (low values are slower and higher quality)
+Transforms include effects of constraints but not parenting/restpose
+Collision Settings
+Collection of cameras
+Command line prompt
+Cache file path
+Object Space
+Driver
+End size of strands in pixels or Blender units
+Weighted result of strip is added to the accumulated results
+NLA Track is selected
+Quaternion
+DOC BROKEN
+19 - Theme Color Set
+Debug State
+Active Keying Set used to insert/delete keyframes
+Lock Rotations (4D)
+Sets the audio output device
+Channels to display when drawing the histogram
+Displays bit depth of full screen display
+Sky Blend
+Reflection
+Vertex group to control roughness 1
+Bake Emit values (glow)
+Language use for translation
+Atmosphere Distance Factor
+Emit Object Space
+Motion Path Points
+IK Solver
+F-Curves
+Semantic interpretation of the property
+Partial overlay on top of the sequencer
+Unborn
+Effect in full or only positive/negative Z direction
+Format of the source data set to render	
+Space UV Editor
+Solid Lights
+F1
+F2
+F3
+F4
+F5
+F6
+F7
+Fonts Directory
+Single ASCII character for this event
+Invert x Axis
+Allow boids to move in air
+Zoom Style
+Library
+Sky related settings for a sun lamp
+Inherit Rotation
+Disable Stereo and Dome environments
+KeyConfigs
+IK Stretch
+Voronoi F1
+Rigid Body
+operator_context
+Rotation Units
+Defines the structure of the menu in the UI
+idp_array
+XYZ velocity mapped to RGB colors
+Editmode
+Particle Location
+Tabs as Spaces
+Region Background
+Render Layers
+Stiff viscosity
+Scale Matrix
+Pinned
+Sequence Editor
+Vertex Normal
+Display current image regardless of object selection
+Display Lattices
+Density
+Exclude raytraced refraction pass from combined
+Charge effector weight
+Limit colliders to this Group
+Square (SV + H)
+Space currently being displayed in this area
+Show frame number beside the current frame indicator line
+Face
+Normalized quaternion rotation
+Proportional Editing enabled
+Vector handle selected color
+Scope region background color
+Show font files
+Wave
+Stickness
+Vertex Groups
+The time to animate the view in milliseconds, zero to disable
+Number of times this datablock is referenced
+Source Path
+Forcefield based on a texture
+Lattices
+Object used as the smoke simulation domain
+Parameters defining which layer, pass and frame of the image is displayed
+Vertex Size
+Italian (Italiano)
+Physics Type
+Ghost
+Audio Device
+Display Scene
+Limit Scale
+Enable Dome environment
+Vertex Group Kink Negate
+Radial Falloff Power
+Value Sliders
+collection
+Meta Elements
+Q
+Display Transforms
+Texture Time Out
+Output image in TIFF format
+Key Map
+Navigation mesh
+Fade effect using the built-in default (usually make transition as long as effect strip)
+Include visualization of ShapeKey related Animation data
+Manual adjust
+Space User Preferences
+NLA Track is not evaluated
+Use rule when boid is on land
+Anisotropic Filter
+Red Green Blue
+Radiance HDR
+Active object base in the scene
+User defined layer of integer number values
+Object Mode
+Maximum height between grid cells the agent can climb
+Texts
+Sort the file list by extension
+Settings for filtering animation data
+Number of horizontal pixels in the screen
+Path to the .blend file
+Converts texture RGB values to intensity (gray) values
+Different styles of displaying the color picker widget
+Initial state when the game starts
+Nurbs order in the U direction (For splines and surfaces), Higher values let points influence a greater area
+Show sliders beside F-Curve channels
+Fisheye
+Show View Name
+Sequencer and Image Preview
+Fake User
+Video Sequence Editor
+Struct Definition
+The directory for storing temporary save files
+Record Animation
+F-Curve Modifier will not be evaluated
+Full Render
+Only one side is rendered, with Z axis pointing in direction of image
+Show ghosts from around the current frame
+Display Channel
+Automatically switch between orthographic and perspective when changing from top/front/side views
+Print debug information for this property
+Update simulation with cache steps
+Relationship Lines
+RNA Path to property affected by F-Curve
+Median Point
+Mesh datablocks
+Sets angular index of refraction for raytraced refraction
+Node Socket type
+Outliner space data
+Shadow X Offset
+Amount of residual error in Blender space unit for constraints that work on position
+Make diffuse shading more similar to shading the surface
+Scale textures for the 3D View (looks nicer but uses more memory and slows image reloading)
+Draw white edges with black outline
+UV selection and display mode
+No
+Show linked objects to the actuator
+Key Config
+Pressure
+Render Data
+Quaternion Rotation
+Multiply
+Control point for envelope F-Modifier
+Proportion of original image source pixel lines to sample
+Avoid Collision
+Snap to volume
+Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)
+Automatically determine the number of threads, based on CPUs
+Curve mapping to map color, vector and scalar values to other values using a user defined curve
+Run python while editing
+Selects the collision type
+Active Vert/Edge/Face
+Tessellation level - check the generated mesh in wireframe mode
+Register
+Transform Markers
+Include visualization of Scene related Animation data
+Index number of cache files
+Text Highlight
+Halo particle effect settings for a Material datablock
+MPlayer
+Previous Particle Location
+Recent Files
+Legacy tracking constraint prone to twisting artifacts
+Edges receive a lift force when passing through surrounding media
+Optional region type keymap is associated with
+Output image in JPEG 2000 format
+Self Collision
+Enable bending constraints
+Theme DopeSheet
+Layer
+Drag Threshold
+Factor Rest Length
+Which style to use for viewport scaling
+Data to derive color results from
+3D cursor location for this view (dependent on local view setting)
+Nested
+MultiLayer
+Display Curve
+Disk Cache
+Transform markers as well as strips
+mode
+Target object for multi-target constraints
+Multiplier for the material's density
+FPS Base
+Grease Pencil Simplify Stroke
+Edit all markers of the same group as one
+Harmonic effector weight
+Location of head end of the bone relative to armature
+Texture coordinates from root particle locations
+Stereo Options
+Disallow movement around the Z axis
+Number of vertical tiles to use while rendering
+Random Friction
+Specifies an offset in the flare seed table
+Horizon brightness
+Language
+Sound Clip
+Light used for OpenGL lighting in solid draw mode
+Screen datablocks
+NLA Editor
+Vertex group to control velocity
+input_count
+Only hold last frame
+Elasticity of collisions
+Sky Texture
+Use SIMD SVBVH
+Sort alphabetically
+New Handles Type
+Display only objects which will be rendered
+Noise
+The time (in ms) for a double click
+matrix
+channel_id
+Only render the active layer
+Material
+Standard Modal Map
+No TC in use
+Output image in multilayer OpenEXR format
+Empty
+Always
+Enable filtering of files
+Template
+When the camera is locked to the view and in fly mode, transform the parent rather than the camera
+Show Sensors
+Auto handle color
+Custom Warp Mesh data file
+Audio Channels
+Available as GameObject attributes in the game engine's python API
+Offset Y
+Min Region Size
+Pre-calculate the raytrace accelerator and render raytracing effects
+For multires, show low resolution while navigating the view
+Active curve spline
+Strength of sky shading exponential exposure correction
+Print Performance to Console
+Power of Fresnel for mirror reflection
+Default binary voxel file format
+Copy Transforms
+Draw alpha transparency channel
+4x4 bone matrix relative to armature
+Edge spring stiffness when longer than rest length
+When true the format is a movie
+Read cache from an external location
+Object Index
+Print warnings when using deprecated features in the python API
+Option Widget Colors
+Auto Depth
+Goal Minimum
+Display size for proportional editing circle
+Point
+NLA Strip
+Strokes
+Lock editing of scale in the interface
+Sensor name
+Point in a shape key
+Dutch (Nederlandse taal)
+Only Objects in Group
+The shininess of the reflection (values < 1.0 give diffuse, blurry reflections)
+Default relative path option for the file selector
+Proportional editing object mode
+Sampled animation data
+Output image in PNG format
+Owner Space
+Align the transformation axes to the selected objects' local space
+If this is set, the panel gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_PT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_PT_hello"
+Lock Rotation (4D Angle)
+Overdraw Sketching
+Pause
+Maximum speed in air
+Backdrop Y offset
+Ellipsoid
+Separate Units
+Object is a fixed obstacle
+scene
+Load user interface setup when loading .blend files
+'Viscosity' inside collision target
+Bake everything
+Lamp
+Negate the effect of the length vertex group
+Invert z axis
+Armature datablocks
+Shadow size in pixels (0, 3 and 5 supported)
+Rasterized cell size
+Collection of timeline markers
+Local
+Old style zoom, continues while moving mouse up or down
+Tooltips
+Edge Collision
+Fluid rest density
+Blender Voxel
+Bezier curve point with two handles
+Runtime
+Regular key pressed as a modifier
+UV Layer
+Initial Velocity
+Sources of input data for evaluating this variable
+Timeline
+Game engine related settings for the object
+Hide Recent Locations
+Include the name of the active camera in image metadata
+Colored Constraints
+Particle Hair Key
+Y Location
+Exec Region Window
+Stereographic techniques
+UV editor settings
+General movement damping
+Estimate matrix
+Global Pivot
+IK X Lock
+Keep UV and edit mode mesh selection in sync
+Vector Handle
+Number of frames from start frame for influence to take effect
+int_array
+Key velocity
+Negate the effect of the roughness 1 vertex group
+Output Path
+Image User
+AutoMerge Editing
+Flare Subsize
+Handle 2 Location
+Edge UV Face Select
+Clamp To
+NDOF
+The transformation of the target is only evaluated in the Pose Space, the target armature object transformation is ignored
+Particle systems emitted from the object
+Wheel Up
+Linear falloff
+Show the status of cached frames in the timeline
+R
+Keyframe
+Blender Render
+Noise Basis
+How the texture effect is calculated (RGB & Curl need a RGB texture else Gradient will be used instead)
+Display Grid Floor
+Transmission Color
+Parameters defining how an Image datablock is used by another datablock
+Spline point without handles
+8 bit color channels
+Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)
+Draw Z-buffer associated with image (mapped from camera clip start to end)
+Filter Size
+Density is constant within lookup radius
+Clear Images before baking
+Animation Channels
+Snap closest point onto target
+Cloth Collision Settings
+Sequence Plugin Directory
+Size of widget handles as percentage of widget radius
+Friction
+Main Speakers
+Offset in the random number table, to get a different randomized result
+Keep Lengths
+Vertex Group Element
+Snap to faces
+Case Sensitive Matches Only
+Time delay in 1/10 seconds before automatically opening sub level menus
+RNA structure definition
+F-Curve Modifier is only applied for the specified frame range to help mask off effects in order to chain them
+Collection of pose bone constraints
+Angle
+Gives a spiraling force that twists the force objects local Z axis
+AAC
+The constraint is applied relative to the local coordinate sytem of the object
+Separate color channels in preview
+Absolute Density
+Target Particle System
+When transforming keyframes, changes to the animation data are flushed to other views
+Markers
+Amount of pixels you have to drag before dragging UI items happens
+Manipulator Hotspot
+Nurb U-lines
+Output video in Ogg format
+double_array
+Shape matching threshold
+Drag component proportional to the square of velocity
+Inner Selected
+Show Playback FPS
+Interpolation
+Space File Browser
+Hold LMB Open Toolbox Delay
+Vertex Group Weight
+Timeline editor space data
+Main Screens
+Improved Perlin
+The value this event translates to in a modal keymap
+Theme settings for widget state colors
+Reversed
+Mesh Float Property
+Sky Exposure
+Align each axis to the Euler rotation axis as used for input
+Show Frame Numbers
+Action Editor
+17 - Theme Color Set
+Soft body simulation settings for an object
+Mesh Vertices
+32-bit Float
+Invisible
+Number of horizontal pixels in the rendered image
+=
+Handle types
+Stricky texture coordinate
+Max Land Angular Velocity
+Struct definition used for properties assigned to this item
+RGB to Intensity
+Mapping settings
+Name of Shape Key
+Shadow Alpha
+Radius Interpolation
+Pulse True Level
+Bounces
+Exec Region Preview
+Edge Draw Type
+Color Management
+Raytrace
+Forcefield depends on the speed of the particles
+Mode
+Stiffness
+Radial
+Noise Method
+Number of seconds between each run of the GL texture garbage collector
+Gravitational constant used for physics simulation in the game engine
+Logic Editor
+Text Selected
+Point Caches
+No compression
+Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed
+Edge Crease
+Invert rotation Axis
+Use Ambient Occlusion to add shadowing based on distance between objects
+Frame that modifier's influence starts (if Restrict Frame Range is in use)
+active_strip
+Lock
+Collection of window managers
+Cine-Flat 24fps 1998x1080
+Sort by extension
+All Views
+Enum Item Definition
+Button 4
+Button 5
+Button 6
+Button 7
+Button 1
+Button 2
+Maximum angles for IK Limit
+Render Pass
+Selected Text
+Whether to draw the sound's waveform
+Data Path
+Enum Flag
+Soft Light
+Define forces for vertices to stick to animated position
+Sample every pixel of the image
+Invert roll axis
+Goal
+Dissolve Speed
+Textbox X Offset
+Sky turbidity
+A random rule is selected for each boid
+OpenAL device - supports 3D audio, recommended for game engine usage
+Console Input
+Invert the level(output) of this sensor
+Memory Cache Limit
+Point Cache List
+Motion Path settings for visualisation
+Endpoint V
+The rotation step for numerical pad keys (2 4 6 8)
+Linear and angular physics
+NLA Strip is selected
+The channel number shown in the image preview. 0 is the result of all strips combined
+Shrink
+Limit movement around the X axis
+Draw Action
+Display debug reporting info
+Collection of action fcurves
+Bone inherits scaling from parent bone
+Lock current frame displayed by layer
+Type of stretch to draw
+Friction/damping with self contact
+Undo
+ZYX Euler
+Scaling factor for the background image
+vBVH
+Axis-Angle Rotation
+Bone deformation weight (for Envelope deform only)
+Interaction radius is a factor of 4 * particle size
+Shape key to use the rest spring lengths from
+Use this texture as a blending value on the next texture
+Deliver environment lighting pass
+Show Python references in tooltips
+Theme NLA Editor
+Above-Below
+Transition Strip
+NLA Strips on this NLA-track
+Draw black edges
+Removes the operator from search results
+Light Override
+Only include channels from Objects in the specified Group
+Compositing
+128
+Random Damping
+Effector Weights
+Location of tail of the channel's bone
+Frame Number
+Image displayed and edited in this space
+Vertex group to control roughness 2
+Show background image in camera view
+How incompressible the fluid is
+Point select mode
+Panel containing UI elements
+Stamp Date
+Inverts the values of the texture to reverse its effect
+Smoke flow settings
+Active Particle System
+Channels
+Type of this region
+Intensity
+Audio Strip
+Blending
+Enable this objects as a collider for physics systems
+Tracking along a single axis
+Weight used by the Subsurf modifier for creasing
+Duplicate Mesh
+Keying Set Info
+Map Type
+Use BLI K-Dop BVH.c
+Amount of turbulence/rotation in fluid
+Add light and shadow
+Random falloff
+Script
+Edge selection mode
+Auto Handle
+Collection of bone groups
+Vertex Group Roughness 1
+Sets minimum X value to for the render border
+Coordinates of the left handle (before the control point)
+Source
+Output Node
+Groups of Pose Channels (Bones)
+Hide recent locations in the file selector
+Particle editing brush
+Show the ground plane grid in perspective view
+Snap Target
+Scripted Expression
+Shadow Brightness
+Noise algorithm - Blender original: Smooth interpolated noise
+Rot error
+Amount of damping during particle collision
+Save Versions
+Anti-aliasing
+Endpoint U
+Sub-Target
+Settings
+Use international fonts
+Show Mini Axis
+Previous Particle Velocity
+Edge in a Mesh datablock
+Function Definition
+Physics engine used for physics simulation in the game engine
+Softbody
+Theme settings for the DopeSheet
+Vertex Group Size
+Add the file format extensions to the rendered file name (eg: filename + .jpg)
+Collection of KeyConfigs
+Active Element
+Wipe
+Deliver raytraced reflection pass
+Fade paths and keys further away from current frame
+Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped
+Control point spring strength values
+Extends by repeating edge pixels of the image
+File is Saved
+Region Type
+OpenEXR
+Auto Keying
+S
+Vector
+Texture Mapping
+Cache name
+Smoke
+Boid State
+Space Node Editor
+Multiresolution
+No Preset
+Maximum allowed number of light inter-reflections
+Final key configuration that combines keymaps from the active and addon configurations, and can be edited by the user
+Allow Negative Frames
+Bending
+Group to override all other lights in this render layer
+Position solver iterations
+Exists
+Lock editing of 'angle' component of four-component rotations in the interface
+Deliver shade-less color pass
+Rear-Truncated
+RNA
+Has Minimum
+Strip has no influence past its extents
+Lennard-Jones effector weight
+Screens
+Window Background
+current_character
+Meta
+Theme settings for the Logic Editor
+Floating-Point Property
+Structural Stiffness
+Particle system settings
+Codec settings for OpenEXR
+Axis
+Forces the current Scene to be displayed in all Screens
+Indicates that a keymap is used for translate modal events for an operator
+Environment map created by the renderer and cached for subsequent renders
+Rotational Difference
+Goal Vertex Group
+Use shaders for GLSL rendering
+Multiple Springs
+Emitter Distance
+Edit Bone
+Indicates that a keyconfig was defined by the user
+Include channels from objects/bone that aren't visible
+Align dynamic game objects along the surface normal, when inside the physics distance area
+Frames Per Second
+Set the distance between the eyes - the camera focal length/30 should be fine
+Draw Other Objects
+Mouse Previous Y Position
+Flare Size
+Align the transformation axes to average normal of selected elements (bone Y axis for pose mode)
+Maintain Volume
+Display mode for the file list
+Max Step
+Activate FALSE level triggering (pulse mode)
+Active Render
+Size Y
+Size X
+Display splash screen on startup
+Size Z
+Grease Pencil Layer
+X/Y coordinates of the curve point
+Use a minimum distance for the field's fall-off
+Show 2D cursor
+Frame Locked
+Active
+Horizontal
+Editing
+Factor for how much surrounding objects contribute to light
+Blend In
+Sets the global starting frame of the movie/sequence, assuming first picture has a #1
+bg_BG
+The size of the occlusion buffer in pixel, use higher value for better precision (slower)
+Horizontal aspect ratio - for anamorphic or non-square pixel output
+4x4 matrix, before constraints
+Minimum Distance
+End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)
+Particles generated by the particle system
+Region Text Highlight
+Align
+zh_TW
+Overwrite existing files while rendering
+Cylinder
+How many frames to fade
+Driver type
+World
+Theme settings for user interface elements
+Bending Stiffness
+Draw other selected objects that share the same image
+Show dashed lines indicating parent or constraint relationships
+And
+Bevel Radius
+Extrapolated
+Force
+Active Brush
+Distance will be used to attenuate shadows
+Method used to adjust the roll of bones when retargeting
+Form Factor
+Scopes to visualize image statistics
+Number
+Shade Top
+Number of frames to render ahead during playback
+High quality interpolation, but slower
+Current view matrix of the 3D region
+Handle 1 Location
+Vertex Group Density
+Active Frame
+IK Y Limit
+Blending to inelastic collision
+Enable high resolution (using amplification)
+Simulation starts on this frame
+Properties to set when the operator is called
+Result of rendering, including all layers and passes
+iTaSC
+Mesh String Property Layer
+Tweak Left
+True if this map is ready for use, False if it needs rendering
+X Scale
+Bone in an Armature datablock
+Output image in Targa format
+Stamp Sequence Strip
+F-Curve Modifier's panel is expanded in UI
+Build 50% proxy resolution
+An object duplicate
+Start Offset
+Items
+Fluid simulation settings for an object taking part in the simulation
+Set audio mixing buffer size to 8192 samples
+Material Strand
+Inflow
+Sort
+Relative Key
+Motion Paths
+Return
+Stiffness defines how much of the element to fill
+Detail mesh simplification max sample error
+Meta Strip
+Bake Alpha values (transparency)
+Memory cache limit in sequencer (megabytes)
+Input configuration, including keymaps
+Select the type of Framing you want
+Animation data for this datablock
+Raytracing
+Key Map Item
+Split quads to give the least distortion while baking
+Show overexposed areas with zebra stripes
+1024
+Bias towards faces further away from the object (in blender units)
+Strip time is controlled by an F-Curve rather than automatically determined
+Bake Location
+sr_RS
+Panel
+Main Libraries
+Edit Edit
+Get away from assigned object or loudest assigned signal source
+Darken
+Active index in vertex group array
+Average Separation
+F-Curve Modifiers
+RNA type used for pointers to any possible data
+Space Image Editor
+UV Selected
+Handle 1 Type
+Choke
+Use Simplify
+Maximum
+YZX Euler
+No Self
+Helicopter Mode
+Rotation in Eulers
+On Cage
+Bone that defines the display transform of this custom shape
+Main Node Trees
+Undo Steps
+Cube Map
+Point cache for physics simulations
+Interactive python console
+Use environment map with six cube sides
+Show .blend files
+Kill Particles
+Sets maximum X value for the render border
+Only Seconds
+NLA Tracks (i.e. Animation Layers)
+Timer Property
+Z Rotation
+Ensure all bone-deforming vertex groups add up to 1.0 while weight painting
+Rigid to Soft Body
+Lock to Object
+Threshold
+Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)
+Occlude Geometry
+Causes surface data to be duplicated with the object
+Use the images alpha values clipped with no blending (binary alpha)
+Hold Forward
+Set Controller state index (1 to 30)
+Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate 
+Lock Horizon
+Ignore Layers
+Object Matrix
+Pixel Aspect X
+Filename
+Use Ambient Occlusion
+The transformation of the target is evaluated relative to its local coordinate system
+The region where the panel is going to be used in
+BW
+Bake Specular values
+Tool
+Margin Column
+Maximum distance from active object to other object (in blender units
+Final transformation value of object or bone
+Group Name
+Proxy parameters for a sequence strip
+fr_FR
+Kill collided particles
+Disable simulation of angular  motion along the Y axis
+Collision Margin
+SMPTE timecode showing minutes, seconds, and frames only. Hours are also shown if necessary, but not by default
+bl_use_preview
+Draw Faces
+Vertex Group Rotation Negate
+\
+New Window
+Turbulent noise driven by particle velocity
+Lock Rotation
+Color Source
+Print state debug info in the game engine
+Location of head of the channel's bone
+Timer
+Output video in Xvid format
+Enable raytraced reflections
+Image Preview
+Optional space type keymap is associated with
+Use ramps for GLSL rendering
+Motion Samples
+Vectorscope Opacity
+Element defining a color at a position in the color ramp
+All Action Keyframes
+Automatic keyframe insertion for Objects and Bones (default setting used for new Scenes)
+Align Object To
+Welding threshold: distance between nearby vertices to be considered equal => set to 0.0 to disable welding test and speed up scene loading (ok if the mesh has no duplicates)
+Limit
+T
+Diffuse Color
+Release
+User defined string text value in a string properties layer
+Histogram for viewing image statistics
+Scroll Widget Colors
+General media friction for point movements
+Lock Y Rotation Axis
+Set audio mixing buffer size to 1024 samples
+Draw the image repeated outside of the main view
+Mesh Int Property
+Noodle curving
+Unknown Type
+Add & Replace
+Border Collisions
+Add children to form a compound collision object
+Influence
+Show high resolution (using amplification)
+Collection of sounds
+Use Bone Heads
+Actuator to apply actions in the game engine
+Mp3
+Go to closest enemy and attack when in range
+Type of range to show for Motion Paths
+Use trackball style rotation in the viewport
+32768
+Overwrite
+Duplicate Particle
+32-bit Signed
+Scale
+Expression to use for Scripted Expression
+Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy
+Parameters
+Material Mode
+Avoid
+Cache is outdated
+File Browser Buttons
+Actor
+Bone Group Index
+Toolbox Column Layout
+Show the frames per second screen refresh rate, while animation is played back
+Image Editor
+Mesh Vertex Sticky Texture Coordinate
+Vertex Weight Proximity
+Average Spring length * Ball Size
+Renders rings over halo
+Offset in the random number table for child particles, to get a different randomized result
+Auto Keying Mode
+B-Bone Segments
+Time in 1/10 seconds to hold the Left Mouse Button before opening the toolbox
+Visible Layers
+File format to save the rendered images as
+Enable view navigation within the camera view
+Show background image in top view
+Sun brightness
+Closest
+Make this curve or surface a closed loop in the U direction
+Command history
+XYZ Rotation Order. Prone to Gimbal Lock
+Draw Stretch Type
+Percentage scale for render resolution
+F-Curve and its keyframes are hidden in the Graph Editor graphs
+F-Curve Editor
+Area distortion between UV and 3D faces
+YXZ Rotation Order. Prone to Gimbal Lock
+Effective but slow compression
+Fields
+For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)
+Process the render result through the compositing pipeline, if compositing nodes are enabled
+Co-ordinate system to cache particles in
+Error Limit
+Curve guide effector weight
+Default
+Black Level
+ISO 1
+Fine tunes texture mapping X, Y and Z locations
+Single Property
+Korean (한국 언어)
+DopeSheet Sub-Channel
+Max Air Speed
+Vertex Group Length Negate
+Key location for a particle over time
+Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample
+Range
+Materials
+Show hidden dot files
+Numpad Enter
+Polish (Polski)
+Automatic saving of temporary files in temp directory, uses process ID
+Cubic B-Spline
+Logic editor space data
+Open menu buttons and pulldowns automatically when the mouse is hovering
+Use to check if an operator is a macro
+Display zoom level
+Stamp Filename
+Weight
+Bias (in radians) to prevent smoothed faces from showing banding (for Raytrace Constant Jittered)
+Auto XYZ to RGB
+UV
+Audio volume
+Restrict the number of animation updates to the animation FPS. This is better for performance, but can cause issues with smooth playback
+Replace
+Show paint related properties
+Target Space
+Gloss Samples
+UI
+Keep horizon level while flying with 3D Mouse
+Texture Mode
+Shaded + Multiple Scattering
+Lifetime
+Settings for particle fluids physics
+Type of units for this property
+Pointer
+Field Settings
+PoseBone Constraints
+Right Ctrl
+User Key Configuration
+Color 3
+Speakers
+Color 1
+Spline Points
+Color 4
+Gradient
+Rule Fuzziness
+YZX Rotation Order. Prone to Gimbal Lock
+Amount of residual error in radiant for constraints that work on orientation
+GLSL Shadows
+Radius of object representation in obstacle simulation
+Show the entire viewport in the display window, using bar horizontally or vertically
+Dissolve Smoke
+Internal
+Library file the datablock is linked from
+Outer face thickness
+Any modifier keys pressed
+Screen aligned billboard
+Allow moving the mouse outside the view on some manipulations (transform, ui control drag)
+NLA Strips that this strip acts as a container for (if it is of type Meta)
+Pixel Cache
+Texture slot name
+Render Stamp
+bl_label
+Settings for interacting with Blender data
+Ball
+Active Clone
+Editbone Matrix
+ja_JP
+Curve in a curve mapping
+Auto Rainbow
+Maximum angular velocity in air (relative to 180 degrees)
+Operator Properties
+Material Raytrace Transparency
+Child
+Modal Keymap
+Color to use behind stamp text
+Theme settings for the graph editor
+Aligned
+Border Maximum X
+Border Maximum Y
+Type of event
+Set color of the bars
+Collapse Summary
+How many collision iterations should be done. (higher is better quality but slower)
+Consant falloff
+Fields Still
+Main Sounds
+Definition of a choice in an RNA enum property
+Translate Tooltips
+Sync Markers
+Object being duplicated
+Face in a Mesh datablock
+Calculate bone paths from tails
+Display World
+UV Pinned
+No Collision
+Active Channel Group
+Make face invisible
+Number of subdivisions of bone (for B-Bones only)
+Renders halo as a lens flare
+Only Selected Channels
+Minimum height where the agent can still walk
+Stroke data points
+Multiply Vertex Group with Envelope
+Inner face thickness
+Set actuator expanded in the user interface
+Low values are slower and higher quality
+Vertices Cache
+Lattice datablocks
+Current frame number can be manually set to a negative value
+Set controller expanded in the user interface
+Simulation used for obstacle avoidance in the game engine
+Duplicate Curve
+List of background images
+Manipulator Handle Size
+Alive
+Lock Z Axis
+Tex
+A square showing Saturation/Value, with Hue slider
+Deliver material index pass
+XXX todo
+Collection of spline points
+Flock
+Linear Light
+Live Unwrap
+Radiosity
+Turbulence Influence
+Object datablocks
+Left Shift
+The source of this force field is the zero point of a harmonic oscillator
+Driver Target
+CIE
+Show High Resolution
+Pin Cloth
+Soft Body Settings
+Threads
+Negate the effect of the roughness end vertex group
+Gloss Threshold
+World Space
+Game data for a Scene datablock
+Blender 2.4
+Coordinates of the right handle (after the control point)
+View2D Buttons List
+F-Curves in this group
+Point cache list
+3D View Region
+Show the X axis line in perspective view
+Matroska
+Node Generic
+Extinction scattering contribution factor
+Callback function defines for builtin Keying Sets
+Generate point density from an object's vertices
+Coulomb friction coefficient, when inside the physics distance area
+Temporary
+Vertex group to control size
+Time in milliseconds between each frame recorded for screencast
+Low Resolution Mesh
+Maximum structural stiffness value
+Maximum radial distance for the field to work
+Collection of point caches
+Volume
+Asymmetry
+Mux rate (bits/s(!))
+Weight value of a vertex in a vertex group
+Log conversion reference blackpoint
+Point density settings
+Show Mouse
+Name of Action Group to assign setting(s) for this path to
+Rotate
+Multiplier for multiple scattered light energy
+09 - Theme Color Set
+(Min+Max)/2 * Ball Size
+Flow
+Output image in Radiance HDR format
+Show Expanded
+11 - Theme Color Set
+Front scattering weight
+Maximum speed for jumping
+Compositor Nodes
+Particle in a particle system
+Vertex Group
+U
+Bending Stiffness Vertex Group
+Context
+Vertex selection mode
+Use scaled but un-grid-fitted kerning distances
+Gloss Amount
+3D region that defines the quad view settings
+Display groups and their datablocks
+Include visualization of Curve related Animation data
+User Modified
+Statistical view of the levels of color in an image
+Anisotropic Friction
+4x
+Inverse Gain
+Fade Time
+Visual Keying
+Agent Height
+Underline
+Translate Interface
+Property Definition
+Bake Mirror colors
+Animated Strip Time
+Friction Factor
+Space data for a screen area
+Maximum speed on land
+Theme User Interface
+Deflect Emitter
+Use Edges
+The base density of the volume
diff --git a/po/update_mo.py b/po/update_mo.py
new file mode 100755
index 00000000000..4effdc65541
--- /dev/null
+++ b/po/update_mo.py
@@ -0,0 +1,17 @@
+#!/usr/bin/python
+
+# update all mo files in the LANGS
+
+import os
+
+LOCALE_DIR="../release/bin/.blender/locale"
+PO_DIR = "."
+DOMAIN = "blender"
+
+for po in os.listdir( PO_DIR ):
+  if po.endswith(".po"):
+    lang = po[:-3]
+    # show stats
+    cmd = "msgfmt --statistics %s.po -o %s/%s/LC_MESSAGES/%s.mo" % ( lang, LOCALE_DIR, lang, DOMAIN )
+    print cmd
+    os.system( cmd )
diff --git a/po/update_po.py b/po/update_po.py
new file mode 100755
index 00000000000..50459c2b14b
--- /dev/null
+++ b/po/update_po.py
@@ -0,0 +1,17 @@
+#!/usr/bin/python
+
+# update all po files in the LANGS
+
+import os
+
+PO_DIR = "."
+DOMAIN = "blender"
+
+for po in os.listdir( PO_DIR ):
+  if po.endswith(".po"):
+    lang = po[:-3]
+    # update po file
+    cmd = "msgmerge --update --lang=%s %s.po %s.pot" % (lang, lang, DOMAIN)
+    print(cmd)
+    os.system( cmd )
+    
diff --git a/po/update_pot.py b/po/update_pot.py
new file mode 100755
index 00000000000..616443edc4a
--- /dev/null
+++ b/po/update_pot.py
@@ -0,0 +1,61 @@
+#!/usr/bin/python
+
+# update the pot file according the POTFILES.in
+
+import os
+
+GETTEXT_XGETTEXT_EXECUTABLE="xgettext"
+SOURCE_DIR=".."
+DOMAIN="blender"
+
+cmd = "%s --files-from=%s/po/POTFILES.in --keyword=_ --keyword=N_ --directory=%s --output=%s/po/%s.pot --from-code=utf-8" % (
+    GETTEXT_XGETTEXT_EXECUTABLE, SOURCE_DIR, SOURCE_DIR, SOURCE_DIR, DOMAIN)
+
+os.system( cmd )
+
+def stripeol(s):
+    if line.endswith("\n"):
+        s = s[:-1]
+
+    if line.endswith("\r"):
+        s = s[:-1]
+
+    return s
+
+pot_messages = {}
+reading_message = False
+message = ""
+with open("blender.pot", 'r') as handle:
+    while True:
+        line = handle.readline()
+
+        if not line:
+            break
+
+        line = stripeol(line)
+        if line.startswith("msgid"):
+            reading_message = True
+            message = line[7:-1]
+        elif line.startswith("msgstr"):
+            reading_message = False
+            pot_messages[message] = True
+        elif reading_message:
+            message += line[1:-1]
+
+# add messages collected automatically from RNA
+with open("blender.pot", "a") as pot_handle:
+    with open("messages.txt", 'r') as handle:
+        while True:
+            line = handle.readline()
+
+            if not line:
+                break
+
+            line = stripeol(line)
+            line = line.replace("\\", "\\\\")
+            line = line.replace("\"", "\\\"")
+
+            if not pot_messages.get(line):
+                pot_handle.write("\n#: Automatically collected from RNA\n")
+                pot_handle.write("msgid \"%s\"\n" % (line))
+                pot_handle.write("msgstr \"\"\n")
diff --git a/release/bin/.blender/.Blanguages b/release/bin/.blender/.Blanguages
index 9f3b3ef80dc..1a83c46039a 100644
--- a/release/bin/.blender/.Blanguages
+++ b/release/bin/.blender/.Blanguages
@@ -11,13 +11,14 @@ Catalan:ca_ES
 Czech:cs_CZ
 Brazilian Portuguese:pt_BR
 Simplified Chinese:zh_CN
+Traditional Chinese:zh_TW
 Russian:ru_RU
 Croatian:hr_HR
-Serbian:sr
+Serbian:sr_RS
 Ukrainian:uk_UA
 Polish:pl_PL
-Romanian:ro
-Arabic:ar
-Bulgarian:bg
-Greek:el
-Korean:ko
+Romanian:ro_RO
+Arabic:ar_SA
+Bulgarian:bg_BG
+Greek:el_GR
+Korean:ko_KR
diff --git a/release/bin/.blender/fonts/droidsans.ttf.gz b/release/bin/.blender/fonts/droidsans.ttf.gz
new file mode 100644
index 00000000000..e83aff4e899
--- /dev/null
+++ b/release/bin/.blender/fonts/droidsans.ttf.gz
diff --git a/release/scripts/startup/bl_operators/wm.py b/release/scripts/startup/bl_operators/wm.py
index 861255f167f..fae38eb1cef 100644
--- a/release/scripts/startup/bl_operators/wm.py
+++ b/release/scripts/startup/bl_operators/wm.py
@@ -1144,6 +1144,67 @@ class WM_OT_sysinfo(Operator):
         return {'FINISHED'}
 
 
+class WM_OT_get_messages(Operator):
+    bl_idname = "wm.get_messages"
+    bl_label = "Get Messages"
+
+    def _putMessage(self, messages, msg):
+        if len(msg):
+            messages[msg] = True
+
+    def _walkProperties(self, properties, messages):
+        for prop in properties:
+            self._putMessage(messages, prop.name)
+            self._putMessage(messages, prop.description)
+
+            if isinstance(prop, bpy.types.EnumProperty):
+                for item in prop.enum_items:
+                    self._putMessage(messages, item.name)
+                    self._putMessage(messages, item.description)
+
+    def _walkRNA(self, bl_rna, messages):
+        if bl_rna.name and bl_rna.name != bl_rna.identifier:
+            self._putMessage(messages, bl_rna.name)
+
+        if bl_rna.description:
+            self._putMessage(messages, bl_rna.description)
+
+        self._walkProperties(bl_rna.properties, messages)
+
+    def _walkClass(self, cls, messages):
+        self._walkRNA(cls.bl_rna, messages)
+
+    def _walk_keymap_hierarchy(self, hier, messages):
+        for lvl in hier:
+            self._putMessage(messages, lvl[0])
+
+            if lvl[3]:
+                self._walk_keymap_hierarchy(lvl[3], messages)
+
+    def execute(self, context):
+        messages = {}
+
+        for cls in type(bpy.context).__base__.__subclasses__():
+            self._walkClass(cls, messages)
+
+        for cls in bpy.types.Space.__subclasses__():
+            self._walkClass(cls, messages)
+
+        for cls in bpy.types.Operator.__subclasses__():
+            self._walkClass(cls, messages)
+
+        from bl_ui.space_userpref_keymap import KM_HIERARCHY
+
+        self._walk_keymap_hierarchy(KM_HIERARCHY, messages)
+
+        text = bpy.data.texts.new(name="messages.txt")
+        for message in messages:
+            text.write(message + "\n")
+        self._walkClass(bpy.types.SpaceDopeSheetEditor, messages)
+
+        return {'FINISHED'}
+
+
 class WM_OT_copy_prev_settings(Operator):
     '''Copy settings from previous version'''
     bl_idname = "wm.copy_prev_settings"
diff --git a/release/scripts/startup/bl_ui/properties_animviz.py b/release/scripts/startup/bl_ui/properties_animviz.py
index 3b33a7ccc61..499ea4c95d4 100644
--- a/release/scripts/startup/bl_ui/properties_animviz.py
+++ b/release/scripts/startup/bl_ui/properties_animviz.py
@@ -23,7 +23,7 @@
 # NOTE:
 # The specialised panel types are derived in their respective UI modules
 # dont register these classes since they are only helpers.
-
+from blf import gettext as _
 
 class MotionPathButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -43,23 +43,23 @@ class MotionPathButtonsPanel():
         col = split.column()
         sub = col.column(align=True)
         if (mps.type == 'CURRENT_FRAME'):
-            sub.prop(mps, "frame_before", text="Before")
-            sub.prop(mps, "frame_after", text="After")
+            sub.prop(mps, "frame_before", text=_("Before"))
+            sub.prop(mps, "frame_after", text=_("After"))
         elif (mps.type == 'RANGE'):
-            sub.prop(mps, "frame_start", text="Start")
-            sub.prop(mps, "frame_end", text="End")
+            sub.prop(mps, "frame_start", text=_("Start"))
+            sub.prop(mps, "frame_end", text=_("End"))
 
-        sub.prop(mps, "frame_step", text="Step")
+        sub.prop(mps, "frame_step", text=_("Step"))
         if bones:
             col.row().prop(mps, "bake_location", expand=True)
 
         col = split.column()
-        col.label(text="Display:")
-        col.prop(mps, "show_frame_numbers", text="Frame Numbers")
-        col.prop(mps, "show_keyframe_highlight", text="Keyframes")
+        col.label(text=_("Display:"))
+        col.prop(mps, "show_frame_numbers", text=_("Frame Numbers"))
+        col.prop(mps, "show_keyframe_highlight", text=_("Keyframes"))
         if bones:
-            col.prop(mps, "show_keyframe_action_all", text="+ Non-Grouped Keyframes")
-        col.prop(mps, "show_keyframe_numbers", text="Keyframe Numbers")
+            col.prop(mps, "show_keyframe_action_all", text=_("+ Non-Grouped Keyframes"))
+        col.prop(mps, "show_keyframe_numbers", text=_("Keyframe Numbers"))
 
 
 # FIXME: this panel still needs to be ported so that it will work correctly with animviz
@@ -82,16 +82,16 @@ class OnionSkinButtonsPanel():
 
         sub = col.column(align=True)
         if arm.ghost_type == 'RANGE':
-            sub.prop(arm, "ghost_frame_start", text="Start")
-            sub.prop(arm, "ghost_frame_end", text="End")
-            sub.prop(arm, "ghost_size", text="Step")
+            sub.prop(arm, "ghost_frame_start", text=_("Start"))
+            sub.prop(arm, "ghost_frame_end", text=_("End"))
+            sub.prop(arm, "ghost_size", text=_("Step"))
         elif arm.ghost_type == 'CURRENT_FRAME':
-            sub.prop(arm, "ghost_step", text="Range")
-            sub.prop(arm, "ghost_size", text="Step")
+            sub.prop(arm, "ghost_step", text=_("Range"))
+            sub.prop(arm, "ghost_size", text=_("Step"))
 
         col = split.column()
-        col.label(text="Display:")
-        col.prop(arm, "show_only_ghost_selected", text="Selected Only")
+        col.label(text=_("Display:"))
+        col.prop(arm, "show_only_ghost_selected", text=_("Selected Only"))
 
 if __name__ == "__main__":  # only for live edit.
     import bpy
diff --git a/release/scripts/startup/bl_ui/properties_data_armature.py b/release/scripts/startup/bl_ui/properties_data_armature.py
index 61093abe814..e5729a24b91 100644
--- a/release/scripts/startup/bl_ui/properties_data_armature.py
+++ b/release/scripts/startup/bl_ui/properties_data_armature.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Panel, Menu
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class ArmatureButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -60,16 +60,16 @@ class DATA_PT_skeleton(ArmatureButtonsPanel, Panel):
         layout.prop(arm, "pose_position", expand=True)
 
         col = layout.column()
-        col.label(text="Layers:")
+        col.label(text=_("Layers:"))
         col.prop(arm, "layers", text="")
-        col.label(text="Protected Layers:")
+        col.label(text=_("Protected Layers:"))
         col.prop(arm, "layers_protected", text="")
 
         layout.label(text="Deform:")
         flow = layout.column_flow()
-        flow.prop(arm, "use_deform_vertex_groups", text="Vertex Groups")
-        flow.prop(arm, "use_deform_envelopes", text="Envelopes")
-        flow.prop(arm, "use_deform_preserve_volume", text="Quaternion")
+        flow.prop(arm, "use_deform_vertex_groups", text=_("Vertex Groups"))
+        flow.prop(arm, "use_deform_envelopes", text=_("Envelopes"))
+        flow.prop(arm, "use_deform_preserve_volume", text=_("Quaternion"))
 
         if context.scene.render.engine == "BLENDER_GAME":
             layout.row().prop(arm, "vert_deformer", expand=True)
@@ -89,15 +89,15 @@ class DATA_PT_display(ArmatureButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(arm, "show_names", text="Names")
-        col.prop(arm, "show_axes", text="Axes")
-        col.prop(arm, "show_bone_custom_shapes", text="Shapes")
+        col.prop(arm, "show_names", text=_("Names"))
+        col.prop(arm, "show_axes", text=_("Axes"))
+        col.prop(arm, "show_bone_custom_shapes", text=_("Shapes"))
 
         col = split.column()
-        col.prop(arm, "show_group_colors", text="Colors")
+        col.prop(arm, "show_group_colors", text=_("Colors"))
         if ob:
-            col.prop(ob, "show_x_ray", text="X-Ray")
-        col.prop(arm, "use_deform_delay", text="Delay Refresh")
+            col.prop(ob, "show_x_ray", text=_("X-Ray"))
+        col.prop(arm, "use_deform_delay", text=_("Delay Refresh"))
 
 
 class DATA_PT_bone_group_specials(Menu):
@@ -161,12 +161,12 @@ class DATA_PT_bone_groups(ArmatureButtonsPanel, Panel):
         row.active = (ob.proxy is None)
 
         sub = row.row(align=True)
-        sub.operator("pose.group_assign", text="Assign")
-        sub.operator("pose.group_unassign", text="Remove")  # row.operator("pose.bone_group_remove_from", text="Remove")
+        sub.operator("pose.group_assign", text=_("Assign"))
+        sub.operator("pose.group_unassign", text=_("Remove"))  # row.operator("pose.bone_group_remove_from", text=_("Remove"))
 
         sub = row.row(align=True)
-        sub.operator("pose.group_select", text="Select")
-        sub.operator("pose.group_deselect", text="Deselect")
+        sub.operator("pose.group_select", text=_("Select"))
+        sub.operator("pose.group_deselect", text=_("Deselect"))
 
 
 class DATA_PT_pose_library(ArmatureButtonsPanel, Panel):
@@ -230,16 +230,16 @@ class DATA_PT_ghost(ArmatureButtonsPanel, Panel):
         col = split.column(align=True)
 
         if arm.ghost_type == 'RANGE':
-            col.prop(arm, "ghost_frame_start", text="Start")
-            col.prop(arm, "ghost_frame_end", text="End")
-            col.prop(arm, "ghost_size", text="Step")
+            col.prop(arm, "ghost_frame_start", text=_("Start"))
+            col.prop(arm, "ghost_frame_end", text=_("End"))
+            col.prop(arm, "ghost_size", text=_("Step"))
         elif arm.ghost_type == 'CURRENT_FRAME':
-            col.prop(arm, "ghost_step", text="Range")
-            col.prop(arm, "ghost_size", text="Step")
+            col.prop(arm, "ghost_step", text=_("Range"))
+            col.prop(arm, "ghost_size", text=_("Step"))
 
         col = split.column()
-        col.label(text="Display:")
-        col.prop(arm, "show_only_ghost_selected", text="Selected Only")
+        col.label(text=_("Display:"))
+        col.prop(arm, "show_only_ghost_selected", text=_("Selected Only"))
 
 
 class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
@@ -263,7 +263,7 @@ class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
             layout.prop(itasc, "mode", expand=True)
             simulation = (itasc.mode == 'SIMULATION')
             if simulation:
-                layout.label(text="Reiteration:")
+                layout.label(text=_("Reiteration:"))
                 layout.prop(itasc, "reiteration_method", expand=True)
 
             row = layout.row()
@@ -275,8 +275,8 @@ class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
                 layout.prop(itasc, "use_auto_step")
                 row = layout.row()
                 if itasc.use_auto_step:
-                    row.prop(itasc, "step_min", text="Min")
-                    row.prop(itasc, "step_max", text="Max")
+                    row.prop(itasc, "step_min", text=_("Min"))
+                    row.prop(itasc, "step_max", text=_("Max"))
                 else:
                     row.prop(itasc, "step_count")
 
@@ -286,7 +286,7 @@ class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
                 layout.prop(itasc, "velocity_max")
             if itasc.solver == 'DLS':
                 row = layout.row()
-                row.prop(itasc, "damping_max", text="Damp", slider=True)
+                row.prop(itasc, "damping_max", text=_("Damp"), slider=True)
                 row.prop(itasc, "damping_epsilon", text="Eps", slider=True)
 
 from bl_ui.properties_animviz import (
@@ -314,8 +314,8 @@ class DATA_PT_motion_paths(MotionPathButtonsPanel, Panel):
         layout.separator()
 
         split = layout.split()
-        split.operator("pose.paths_calculate", text="Calculate Paths")
-        split.operator("pose.paths_clear", text="Clear Paths")
+        split.operator("pose.paths_calculate", text=_("Calculate Paths"))
+        split.operator("pose.paths_clear", text=_("Clear Paths"))
 
 
 class DATA_PT_onion_skinning(OnionSkinButtonsPanel):  # , Panel): # inherit from panel when ready
diff --git a/release/scripts/startup/bl_ui/properties_data_bone.py b/release/scripts/startup/bl_ui/properties_data_bone.py
index b3eaf88d5bf..2c9b31fd88d 100644
--- a/release/scripts/startup/bl_ui/properties_data_bone.py
+++ b/release/scripts/startup/bl_ui/properties_data_bone.py
@@ -21,7 +21,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class BoneButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -76,14 +76,14 @@ class BONE_PT_transform(BoneButtonsPanel, Panel):
 
             col = row.column()
             if pchan.rotation_mode == 'QUATERNION':
-                col.prop(pchan, "rotation_quaternion", text="Rotation")
+                col.prop(pchan, "rotation_quaternion", text=_("Rotation"))
             elif pchan.rotation_mode == 'AXIS_ANGLE':
-                #col.label(text="Rotation")
-                #col.prop(pchan, "rotation_angle", text="Angle")
-                #col.prop(pchan, "rotation_axis", text="Axis")
-                col.prop(pchan, "rotation_axis_angle", text="Rotation")
+                #col.label(text=_("Rotation"))
+                #col.prop(pchan, "rotation_angle", text=_("Angle"))
+                #col.prop(pchan, "rotation_axis", text=_("Axis"))
+                col.prop(pchan, "rotation_axis_angle", text=_("Rotation"))
             else:
-                col.prop(pchan, "rotation_euler", text="Rotation")
+                col.prop(pchan, "rotation_euler", text=_("Rotation"))
 
             row.column().prop(pchan, "scale")
 
@@ -97,7 +97,7 @@ class BONE_PT_transform(BoneButtonsPanel, Panel):
 
             col = row.column()
             sub = col.column(align=True)
-            sub.label(text="Roll:")
+            sub.label(text=_("Roll:"))
             sub.prop(bone, "roll", text="")
             sub.label()
             sub.prop(bone, "lock")
@@ -126,12 +126,12 @@ class BONE_PT_transform_locks(BoneButtonsPanel, Panel):
 
         col = row.column()
         if pchan.rotation_mode in {'QUATERNION', 'AXIS_ANGLE'}:
-            col.prop(pchan, "lock_rotations_4d", text="Lock Rotation")
+            col.prop(pchan, "lock_rotations_4d", text=_("Lock Rotation"))
             if pchan.lock_rotations_4d:
                 col.prop(pchan, "lock_rotation_w", text="W")
             col.prop(pchan, "lock_rotation", text="")
         else:
-            col.prop(pchan, "lock_rotation", text="Rotation")
+            col.prop(pchan, "lock_rotation", text=_("Rotation"))
 
         row.column().prop(pchan, "lock_scale")
 
@@ -155,17 +155,17 @@ class BONE_PT_relations(BoneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Layers:")
+        col.label(text=_("Layers:"))
         col.prop(bone, "layers", text="")
 
         col.separator()
 
         if ob and pchan:
-            col.label(text="Bone Group:")
+            col.label(text=_("Bone Group:"))
             col.prop_search(pchan, "bone_group", ob.pose, "bone_groups", text="")
 
         col = split.column()
-        col.label(text="Parent:")
+        col.label(text=_("Parent:"))
         if context.bone:
             col.prop(bone, "parent", text="")
         else:
@@ -174,11 +174,11 @@ class BONE_PT_relations(BoneButtonsPanel, Panel):
         sub = col.column()
         sub.active = (bone.parent is not None)
         sub.prop(bone, "use_connect")
-        sub.prop(bone, "use_inherit_rotation", text="Inherit Rotation")
-        sub.prop(bone, "use_inherit_scale", text="Inherit Scale")
+        sub.prop(bone, "use_inherit_rotation", text=_("Inherit Rotation"))
+        sub.prop(bone, "use_inherit_scale", text=_("Inherit Scale"))
         sub = col.column()
         sub.active = (not bone.parent or not bone.use_connect)
-        sub.prop(bone, "use_local_location", text="Local Location")
+        sub.prop(bone, "use_local_location", text=_("Local Location"))
 
 
 class BONE_PT_display(BoneButtonsPanel, Panel):
@@ -206,16 +206,16 @@ class BONE_PT_display(BoneButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.prop(bone, "show_wire", text="Wireframe")
-            col.prop(bone, "hide", text="Hide")
+            col.prop(bone, "show_wire", text=_("Wireframe"))
+            col.prop(bone, "hide", text=_("Hide"))
 
             if pchan:
                 col = split.column()
 
-                col.label(text="Custom Shape:")
+                col.label(text=_("Custom Shape:"))
                 col.prop(pchan, "custom_shape", text="")
                 if pchan.custom_shape:
-                    col.prop_search(pchan, "custom_shape_transform", ob.pose, "bones", text="At")
+                    col.prop_search(pchan, "custom_shape_transform", ob.pose, "bones", text=_("At"))
 
 
 class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
@@ -241,13 +241,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         split.prop(pchan, "lock_ik_x", icon='LOCKED' if pchan.lock_ik_x else 'UNLOCKED', text="X")
         split.active = pchan.is_in_ik_chain
         row = split.row()
-        row.prop(pchan, "ik_stiffness_x", text="Stiffness", slider=True)
+        row.prop(pchan, "ik_stiffness_x", text=_("Stiffness"), slider=True)
         row.active = pchan.lock_ik_x == False and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
         sub = split.row()
 
-        sub.prop(pchan, "use_ik_limit_x", text="Limit")
+        sub.prop(pchan, "use_ik_limit_x", text=_("Limit"))
         sub.active = pchan.lock_ik_x == False and pchan.is_in_ik_chain
         sub = split.row(align=True)
         sub.prop(pchan, "ik_min_x", text="")
@@ -258,13 +258,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         split.prop(pchan, "lock_ik_y", icon='LOCKED' if pchan.lock_ik_y else 'UNLOCKED', text="Y")
         split.active = pchan.is_in_ik_chain
         row = split.row()
-        row.prop(pchan, "ik_stiffness_y", text="Stiffness", slider=True)
+        row.prop(pchan, "ik_stiffness_y", text=_("Stiffness"), slider=True)
         row.active = pchan.lock_ik_y == False and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
         sub = split.row()
 
-        sub.prop(pchan, "use_ik_limit_y", text="Limit")
+        sub.prop(pchan, "use_ik_limit_y", text=_("Limit"))
         sub.active = pchan.lock_ik_y == False and pchan.is_in_ik_chain
 
         sub = split.row(align=True)
@@ -276,13 +276,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         split.prop(pchan, "lock_ik_z", icon='LOCKED' if pchan.lock_ik_z else 'UNLOCKED', text="Z")
         split.active = pchan.is_in_ik_chain
         sub = split.row()
-        sub.prop(pchan, "ik_stiffness_z", text="Stiffness", slider=True)
+        sub.prop(pchan, "ik_stiffness_z", text=_("Stiffness"), slider=True)
         sub.active = pchan.lock_ik_z == False and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
         sub = split.row()
 
-        sub.prop(pchan, "use_ik_limit_z", text="Limit")
+        sub.prop(pchan, "use_ik_limit_z", text=_("Limit"))
         sub.active = pchan.lock_ik_z == False and pchan.is_in_ik_chain
         sub = split.row(align=True)
         sub.prop(pchan, "ik_min_z", text="")
@@ -290,7 +290,7 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         sub.active = pchan.lock_ik_z == False and pchan.use_ik_limit_z and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
-        split.label(text="Stretch:")
+        split.label(text=_("Stretch:"))
         sub = split.row()
         sub.prop(pchan, "ik_stretch", text="", slider=True)
         sub.active = pchan.is_in_ik_chain
@@ -298,15 +298,15 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         if ob.pose.ik_solver == 'ITASC':
             split = layout.split()
             col = split.column()
-            col.prop(pchan, "use_ik_rotation_control", text="Control Rotation")
+            col.prop(pchan, "use_ik_rotation_control", text=_("Control Rotation"))
             col.active = pchan.is_in_ik_chain
             col = split.column()
-            col.prop(pchan, "ik_rotation_weight", text="Weight", slider=True)
+            col.prop(pchan, "ik_rotation_weight", text=_("Weight"), slider=True)
             col.active = pchan.is_in_ik_chain
             # not supported yet
             #row = layout.row()
-            #row.prop(pchan, "use_ik_linear_control", text="Joint Size")
-            #row.prop(pchan, "ik_linear_weight", text="Weight", slider=True)
+            #row.prop(pchan, "use_ik_linear_control", text=_("Joint Size"))
+            #row.prop(pchan, "ik_linear_weight", text=_("Weight"), slider=True)
 
 
 class BONE_PT_deform(BoneButtonsPanel, Panel):
@@ -334,27 +334,27 @@ class BONE_PT_deform(BoneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Envelope:")
+        col.label(text=_("Envelope:"))
 
         sub = col.column(align=True)
-        sub.prop(bone, "envelope_distance", text="Distance")
-        sub.prop(bone, "envelope_weight", text="Weight")
-        col.prop(bone, "use_envelope_multiply", text="Multiply")
+        sub.prop(bone, "envelope_distance", text=_("Distance"))
+        sub.prop(bone, "envelope_weight", text=_("Weight"))
+        col.prop(bone, "use_envelope_multiply", text=_("Multiply"))
 
         sub = col.column(align=True)
-        sub.label(text="Radius:")
-        sub.prop(bone, "head_radius", text="Head")
-        sub.prop(bone, "tail_radius", text="Tail")
+        sub.label(text=_("Radius:"))
+        sub.prop(bone, "head_radius", text=_("Head"))
+        sub.prop(bone, "tail_radius", text=_("Tail"))
 
         col = split.column()
-        col.label(text="Curved Bones:")
+        col.label(text=_("Curved Bones:"))
 
         sub = col.column(align=True)
-        sub.prop(bone, "bbone_segments", text="Segments")
-        sub.prop(bone, "bbone_in", text="Ease In")
-        sub.prop(bone, "bbone_out", text="Ease Out")
+        sub.prop(bone, "bbone_segments", text=_("Segments"))
+        sub.prop(bone, "bbone_in", text=_("Ease In"))
+        sub.prop(bone, "bbone_out", text=_("Ease Out"))
 
-        col.label(text="Offset:")
+        col.label(text=_("Offset:"))
         col.prop(bone, "use_cyclic_offset")
 
 
diff --git a/release/scripts/startup/bl_ui/properties_data_camera.py b/release/scripts/startup/bl_ui/properties_data_camera.py
index 5255af40951..0d79ec99789 100644
--- a/release/scripts/startup/bl_ui/properties_data_camera.py
+++ b/release/scripts/startup/bl_ui/properties_data_camera.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class CameraButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -91,16 +91,16 @@ class DATA_PT_camera(CameraButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text="Shift:")
+        col.label(text=_("Shift:"))
         col.prop(cam, "shift_x", text="X")
         col.prop(cam, "shift_y", text="Y")
 
         col = split.column(align=True)
-        col.label(text="Clipping:")
-        col.prop(cam, "clip_start", text="Start")
-        col.prop(cam, "clip_end", text="End")
+        col.label(text=_("Clipping:"))
+        col.prop(cam, "clip_start", text=_("Start"))
+        col.prop(cam, "clip_end", text=_("End"))
 
-        layout.label(text="Depth of Field:")
+        layout.label(text=_("Depth of Field:"))
 
         split = layout.split()
         split.prop(cam, "dof_object", text="")
@@ -109,7 +109,7 @@ class DATA_PT_camera(CameraButtonsPanel, Panel):
 
         if cam.dof_object is not None:
             col.enabled = False
-        col.prop(cam, "dof_distance", text="Distance")
+        col.prop(cam, "dof_distance", text=_("Distance"))
 
 
 class DATA_PT_camera_display(CameraButtonsPanel, Panel):
@@ -124,19 +124,19 @@ class DATA_PT_camera_display(CameraButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(cam, "show_limits", text="Limits")
-        col.prop(cam, "show_mist", text="Mist")
-        col.prop(cam, "show_title_safe", text="Title Safe")
-        col.prop(cam, "show_name", text="Name")
+        col.prop(cam, "show_limits", text=_("Limits"))
+        col.prop(cam, "show_mist", text=_("Mist"))
+        col.prop(cam, "show_title_safe", text=_("Title Safe"))
+        col.prop(cam, "show_name", text=_("Name"))
         col.prop_menu_enum(cam, "show_guide")
 
         col = split.column()
-        col.prop(cam, "draw_size", text="Size")
+        col.prop(cam, "draw_size", text=_("Size"))
         col.separator()
-        col.prop(cam, "show_passepartout", text="Passepartout")
+        col.prop(cam, "show_passepartout", text=_("Passepartout"))
         sub = col.column()
         sub.active = cam.show_passepartout
-        sub.prop(cam, "passepartout_alpha", text="Alpha", slider=True)
+        sub.prop(cam, "passepartout_alpha", text=_("Alpha"), slider=True)
 
 
 class DATA_PT_custom_props_camera(CameraButtonsPanel, PropertyPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_data_curve.py b/release/scripts/startup/bl_ui/properties_data_curve.py
index 2e0b36a7a75..861359fbed4 100644
--- a/release/scripts/startup/bl_ui/properties_data_curve.py
+++ b/release/scripts/startup/bl_ui/properties_data_curve.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class CurveButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -67,7 +67,7 @@ class DATA_PT_context_curve(CurveButtonsPanel, Panel):
 
 
 class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
-    bl_label = "Shape"
+    bl_label = _("Shape")
 
     def draw(self, context):
         layout = self.layout
@@ -85,17 +85,17 @@ class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Resolution:")
+        col.label(text=_("Resolution:"))
         sub = col.column(align=True)
-        sub.prop(curve, "resolution_u", text="Preview U")
-        sub.prop(curve, "render_resolution_u", text="Render U")
+        sub.prop(curve, "resolution_u", text=_("Preview U"))
+        sub.prop(curve, "render_resolution_u", text=_("Render U"))
         if is_curve:
-            col.label(text="Twisting:")
+            col.label(text=_("Twisting:"))
             col.prop(curve, "twist_mode", text="")
-            col.prop(curve, "twist_smooth", text="Smooth")
+            col.prop(curve, "twist_smooth", text=_("Smooth"))
         if is_text:
-            col.label(text="Display:")
-            col.prop(curve, "use_fast_edit", text="Fast Editing")
+            col.label(text=_("Display:"))
+            col.prop(curve, "use_fast_edit", text=_("Fast Editing"))
 
         col = split.column()
 
@@ -103,15 +103,15 @@ class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
             sub = col.column()
             sub.label(text="")
             sub = col.column(align=True)
-            sub.prop(curve, "resolution_v", text="Preview V")
-            sub.prop(curve, "render_resolution_v", text="Render V")
+            sub.prop(curve, "resolution_v", text=_("Preview V"))
+            sub.prop(curve, "render_resolution_v", text=_("Render V"))
 
         if (is_curve or is_text):
-            col.label(text="Fill:")
+            col.label(text=_("Fill:"))
             sub = col.column()
             sub.active = (curve.dimensions == '2D' or (curve.bevel_object is None and curve.dimensions == '3D'))
             sub.prop(curve, "fill_mode", text="")
-            col.prop(curve, "use_fill_deform", text="Fill Deformed")
+            col.prop(curve, "use_fill_deform", text=_("Fill Deformed"))
 
 
 class DATA_PT_curve_texture_space(CurveButtonsPanel, Panel):
@@ -129,8 +129,8 @@ class DATA_PT_curve_texture_space(CurveButtonsPanel, Panel):
         row.prop(curve, "use_uv_as_generated")
 
         row = layout.row()
-        row.column().prop(curve, "texspace_location", text="Location")
-        row.column().prop(curve, "texspace_size", text="Size")
+        row.column().prop(curve, "texspace_location", text=_("Location"))
+        row.column().prop(curve, "texspace_size", text=_("Size"))
 
 
 class DATA_PT_geometry_curve(CurveButtonsPanel, Panel):
@@ -152,17 +152,17 @@ class DATA_PT_geometry_curve(CurveButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Modification:")
+        col.label(text=_("Modification:"))
         col.prop(curve, "offset")
         col.prop(curve, "extrude")
-        col.label(text="Taper Object:")
+        col.label(text=_("Taper Object:"))
         col.prop(curve, "taper_object", text="")
 
         col = split.column()
-        col.label(text="Bevel:")
-        col.prop(curve, "bevel_depth", text="Depth")
-        col.prop(curve, "bevel_resolution", text="Resolution")
-        col.label(text="Bevel Object:")
+        col.label(text=_("Bevel:"))
+        col.prop(curve, "bevel_depth", text=_("Depth"))
+        col.prop(curve, "bevel_resolution", text=_("Resolution"))
+        col.label(text=_("Bevel Object:"))
         col.prop(curve, "bevel_object", text="")
 
 
@@ -182,7 +182,7 @@ class DATA_PT_pathanim(CurveButtonsPanelCurve, Panel):
         layout.active = curve.use_path
 
         col = layout.column()
-        layout.prop(curve, "path_duration", text="Frames")
+        layout.prop(curve, "path_duration", text=_("Frames"))
         layout.prop(curve, "eval_time")
 
         split = layout.split()
@@ -194,7 +194,7 @@ class DATA_PT_pathanim(CurveButtonsPanelCurve, Panel):
 
         col = split.column()
         col.prop(curve, "use_radius")
-        col.prop(curve, "use_time_offset", text="Offset Children")
+        col.prop(curve, "use_time_offset", text=_("Offset Children"))
 
 
 class DATA_PT_active_spline(CurveButtonsPanelActive, Panel):
@@ -215,20 +215,20 @@ class DATA_PT_active_spline(CurveButtonsPanelActive, Panel):
             # These settings are below but its easier to have
             # poly's set aside since they use so few settings
             col = split.column()
-            col.label(text="Cyclic:")
+            col.label(text=_("Cyclic:"))
             col.prop(act_spline, "use_smooth")
             col = split.column()
             col.prop(act_spline, "use_cyclic_u", text="U")
 
         else:
             col = split.column()
-            col.label(text="Cyclic:")
+            col.label(text=_("Cyclic:"))
             if act_spline.type == 'NURBS':
-                col.label(text="Bezier:")
-                col.label(text="Endpoint:")
-                col.label(text="Order:")
+                col.label(text=_("Bezier:"))
+                col.label(text=_("Endpoint:"))
+                col.label(text=_("Order:"))
 
-            col.label(text="Resolution:")
+            col.label(text=_("Resolution:"))
 
             col = split.column()
             col.prop(act_spline, "use_cyclic_u", text="U")
@@ -261,9 +261,9 @@ class DATA_PT_active_spline(CurveButtonsPanelActive, Panel):
                 col = split.column()
                 col.active = (curve.dimensions == '3D')
 
-                col.label(text="Interpolation:")
-                col.prop(act_spline, "tilt_interpolation", text="Tilt")
-                col.prop(act_spline, "radius_interpolation", text="Radius")
+                col.label(text=_("Interpolation:"))
+                col.prop(act_spline, "tilt_interpolation", text=_("Tilt"))
+                col.prop(act_spline, "radius_interpolation", text=_("Radius"))
 
             layout.prop(act_spline, "use_smooth")
 
@@ -282,16 +282,16 @@ class DATA_PT_font(CurveButtonsPanel, Panel):
         char = context.curve.edit_format
 
         row = layout.split(percentage=0.25)
-        row.label(text="Regular")
+        row.label(text=_("Regular"))
         row.template_ID(text, "font", open="font.open", unlink="font.unlink")
         row = layout.split(percentage=0.25)
-        row.label(text="Bold")
+        row.label(text=_("Bold"))
         row.template_ID(text, "font_bold", open="font.open", unlink="font.unlink")
         row = layout.split(percentage=0.25)
-        row.label(text="Italic")
+        row.label(text=_("Italic"))
         row.template_ID(text, "font_italic", open="font.open", unlink="font.unlink")
         row = layout.split(percentage=0.25)
-        row.label(text="Bold & Italic")
+        row.label(text=_("Bold & Italic"))
         row.template_ID(text, "font_bold_italic", open="font.open", unlink="font.unlink")
 
         #layout.prop(text, "font")
@@ -299,36 +299,36 @@ class DATA_PT_font(CurveButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(text, "size", text="Size")
+        col.prop(text, "size", text=_("Size"))
         col = split.column()
         col.prop(text, "shear")
 
         split = layout.split()
 
         col = split.column()
-        col.label(text="Object Font:")
+        col.label(text=_("Object Font:"))
         col.prop(text, "family", text="")
 
         col = split.column()
-        col.label(text="Text on Curve:")
+        col.label(text=_("Text on Curve:"))
         col.prop(text, "follow_curve", text="")
 
         split = layout.split()
 
         col = split.column()
         colsub = col.column(align=True)
-        colsub.label(text="Underline:")
-        colsub.prop(text, "underline_position", text="Position")
-        colsub.prop(text, "underline_height", text="Thickness")
+        colsub.label(text=_("Underline:"))
+        colsub.prop(text, "underline_position", text=_("Position"))
+        colsub.prop(text, "underline_height", text=_("Thickness"))
 
         col = split.column()
-        col.label(text="Character:")
+        col.label(text=_("Character:"))
         col.prop(char, "use_bold")
         col.prop(char, "use_italic")
         col.prop(char, "use_underline")
 
         row = layout.row()
-        row.prop(text, "small_caps_scale", text="Small Caps")
+        row.prop(text, "small_caps_scale", text=_("Small Caps"))
         row.prop(char, "use_small_caps")
 
 
@@ -344,19 +344,19 @@ class DATA_PT_paragraph(CurveButtonsPanel, Panel):
 
         text = context.curve
 
-        layout.label(text="Align:")
+        layout.label(text=_("Align:"))
         layout.prop(text, "align", expand=True)
 
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text="Spacing:")
-        col.prop(text, "space_character", text="Character")
-        col.prop(text, "space_word", text="Word")
-        col.prop(text, "space_line", text="Line")
+        col.label(text=_("Spacing:"))
+        col.prop(text, "space_character", text=_("Character"))
+        col.prop(text, "space_word", text=_("Word"))
+        col.prop(text, "space_line", text=_("Line"))
 
         col = split.column(align=True)
-        col.label(text="Offset:")
+        col.label(text=_("Offset:"))
         col.prop(text, "offset_x", text="X")
         col.prop(text, "offset_y", text="Y")
 
@@ -388,13 +388,13 @@ class DATA_PT_text_boxes(CurveButtonsPanel, Panel):
 
             col = split.column(align=True)
 
-            col.label(text="Dimensions:")
-            col.prop(box, "width", text="Width")
-            col.prop(box, "height", text="Height")
+            col.label(text=_("Dimensions:"))
+            col.prop(box, "width", text=_("Width"))
+            col.prop(box, "height", text=_("Height"))
 
             col = split.column(align=True)
 
-            col.label(text="Offset:")
+            col.label(text=_("Offset:"))
             col.prop(box, "x", text="X")
             col.prop(box, "y", text="Y")
 
diff --git a/release/scripts/startup/bl_ui/properties_data_empty.py b/release/scripts/startup/bl_ui/properties_data_empty.py
index c781873e16c..b6fa6d8e839 100644
--- a/release/scripts/startup/bl_ui/properties_data_empty.py
+++ b/release/scripts/startup/bl_ui/properties_data_empty.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 class DataButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -39,17 +39,17 @@ class DATA_PT_empty(DataButtonsPanel, Panel):
 
         ob = context.object
 
-        layout.prop(ob, "empty_draw_type", text="Display")
+        layout.prop(ob, "empty_draw_type", text=_("Display"))
 
         if ob.empty_draw_type == 'IMAGE':
             layout.template_ID(ob, "data", open="image.open", unlink="image.unlink")
 
-            layout.prop(ob, "color", text="Transparency", index=3, slider=True)
+            layout.prop(ob, "color", text=_("Transparency"), index=3, slider=True)
             row = layout.row(align=True)
-            row.prop(ob, "empty_image_offset", text="Offset X", index=0)
-            row.prop(ob, "empty_image_offset", text="Offset Y", index=1)
+            row.prop(ob, "empty_image_offset", text=_("Offset X"), index=0)
+            row.prop(ob, "empty_image_offset", text=_("Offset Y"), index=1)
 
-        layout.prop(ob, "empty_draw_size", text="Size")
+        layout.prop(ob, "empty_draw_size", text=_("Size"))
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)
diff --git a/release/scripts/startup/bl_ui/properties_data_lamp.py b/release/scripts/startup/bl_ui/properties_data_lamp.py
index 4ff180f74fb..93ed8ca369b 100644
--- a/release/scripts/startup/bl_ui/properties_data_lamp.py
+++ b/release/scripts/startup/bl_ui/properties_data_lamp.py
@@ -20,10 +20,10 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class LAMP_MT_sunsky_presets(Menu):
-    bl_label = "Sun & Sky Presets"
+    bl_label = _("Sun & Sky Presets")
     preset_subdir = "sunsky"
     preset_operator = "script.execute_preset"
     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
@@ -93,15 +93,15 @@ class DATA_PT_lamp(DataButtonsPanel, Panel):
         sub.prop(lamp, "energy")
 
         if lamp.type in {'POINT', 'SPOT'}:
-            sub.label(text="Falloff:")
+            sub.label(text=_("Falloff:"))
             sub.prop(lamp, "falloff_type", text="")
             sub.prop(lamp, "distance")
 
             if lamp.falloff_type == 'LINEAR_QUADRATIC_WEIGHTED':
-                col.label(text="Attenuation Factors:")
+                col.label(text=_("Attenuation Factors:"))
                 sub = col.column(align=True)
-                sub.prop(lamp, "linear_attenuation", slider=True, text="Linear")
-                sub.prop(lamp, "quadratic_attenuation", slider=True, text="Quadratic")
+                sub.prop(lamp, "linear_attenuation", slider=True, text=_("Linear"))
+                sub.prop(lamp, "quadratic_attenuation", slider=True, text=_("Quadratic"))
 
             col.prop(lamp, "use_sphere")
 
@@ -111,7 +111,7 @@ class DATA_PT_lamp(DataButtonsPanel, Panel):
 
         col = split.column()
         col.prop(lamp, "use_negative")
-        col.prop(lamp, "use_own_layer", text="This Layer Only")
+        col.prop(lamp, "use_own_layer", text=_("This Layer Only"))
         col.prop(lamp, "use_specular")
         col.prop(lamp, "use_diffuse")
 
@@ -139,34 +139,34 @@ class DATA_PT_sunsky(DataButtonsPanel, Panel):
 
         row = layout.row()
         row.active = lamp.use_sky or lamp.use_atmosphere
-        row.prop(lamp, "atmosphere_turbidity", text="Turbidity")
+        row.prop(lamp, "atmosphere_turbidity", text=_("Turbidity"))
 
         split = layout.split()
 
         col = split.column()
         col.active = lamp.use_sky
-        col.label(text="Blending:")
+        col.label(text=_("Blending:"))
         sub = col.column()
         sub.prop(lamp, "sky_blend_type", text="")
-        sub.prop(lamp, "sky_blend", text="Factor")
+        sub.prop(lamp, "sky_blend", text=_("Factor"))
 
-        col.label(text="Color Space:")
+        col.label(text=_("Color Space:"))
         sub = col.column()
         sub.row().prop(lamp, "sky_color_space", expand=True)
-        sub.prop(lamp, "sky_exposure", text="Exposure")
+        sub.prop(lamp, "sky_exposure", text=_("Exposure"))
 
         col = split.column()
         col.active = lamp.use_sky
-        col.label(text="Horizon:")
+        col.label(text=_("Horizon:"))
         sub = col.column()
-        sub.prop(lamp, "horizon_brightness", text="Brightness")
-        sub.prop(lamp, "spread", text="Spread")
+        sub.prop(lamp, "horizon_brightness", text=_("Brightness"))
+        sub.prop(lamp, "spread", text=_("Spread"))
 
-        col.label(text="Sun:")
+        col.label(text=_("Sun:"))
         sub = col.column()
-        sub.prop(lamp, "sun_brightness", text="Brightness")
-        sub.prop(lamp, "sun_size", text="Size")
-        sub.prop(lamp, "backscattered_light", slider=True, text="Back Light")
+        sub.prop(lamp, "sun_brightness", text=_("Brightness"))
+        sub.prop(lamp, "sun_size", text=_("Size"))
+        sub.prop(lamp, "backscattered_light", slider=True, text=_("Back Light"))
 
         layout.separator()
 
@@ -176,16 +176,16 @@ class DATA_PT_sunsky(DataButtonsPanel, Panel):
 
         col = split.column()
         col.active = lamp.use_atmosphere
-        col.label(text="Intensity:")
-        col.prop(lamp, "sun_intensity", text="Sun")
-        col.prop(lamp, "atmosphere_distance_factor", text="Distance")
+        col.label(text=_("Intensity:"))
+        col.prop(lamp, "sun_intensity", text=_("Sun"))
+        col.prop(lamp, "atmosphere_distance_factor", text=_("Distance"))
 
         col = split.column()
         col.active = lamp.use_atmosphere
-        col.label(text="Scattering:")
+        col.label(text=_("Scattering:"))
         sub = col.column(align=True)
-        sub.prop(lamp, "atmosphere_inscattering", slider=True, text="Inscattering")
-        sub.prop(lamp, "atmosphere_extinction", slider=True, text="Extinction")
+        sub.prop(lamp, "atmosphere_inscattering", slider=True, text=_("Inscattering"))
+        sub.prop(lamp, "atmosphere_extinction", slider=True, text=_("Extinction"))
 
 
 class DATA_PT_shadow(DataButtonsPanel, Panel):
@@ -209,15 +209,15 @@ class DATA_PT_shadow(DataButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text="Form factor sampling:")
+            col.label(text=_("Form factor sampling:"))
 
             sub = col.row(align=True)
 
             if lamp.shape == 'SQUARE':
-                sub.prop(lamp, "shadow_ray_samples_x", text="Samples")
+                sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples"))
             elif lamp.shape == 'RECTANGLE':
-                sub.prop(lamp, "shadow_ray_samples_x", text="Samples X")
-                sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y")
+                sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples X"))
+                sub.prop(lamp, "shadow_ray_samples_y", text=_("Samples Y"))
 
         if lamp.shadow_method != 'NOSHADOW':
             split = layout.split()
@@ -226,34 +226,34 @@ class DATA_PT_shadow(DataButtonsPanel, Panel):
             col.prop(lamp, "shadow_color", text="")
 
             col = split.column()
-            col.prop(lamp, "use_shadow_layer", text="This Layer Only")
+            col.prop(lamp, "use_shadow_layer", text=_("This Layer Only"))
             col.prop(lamp, "use_only_shadow")
 
         if lamp.shadow_method == 'RAY_SHADOW':
             split = layout.split()
 
             col = split.column()
-            col.label(text="Sampling:")
+            col.label(text=_("Sampling:"))
 
             if lamp.type in {'POINT', 'SUN', 'SPOT'}:
                 sub = col.row()
 
-                sub.prop(lamp, "shadow_ray_samples", text="Samples")
-                sub.prop(lamp, "shadow_soft_size", text="Soft Size")
+                sub.prop(lamp, "shadow_ray_samples", text=_("Samples"))
+                sub.prop(lamp, "shadow_soft_size", text=_("Soft Size"))
 
             elif lamp.type == 'AREA':
                 sub = col.row(align=True)
 
                 if lamp.shape == 'SQUARE':
-                    sub.prop(lamp, "shadow_ray_samples_x", text="Samples")
+                    sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples"))
                 elif lamp.shape == 'RECTANGLE':
-                    sub.prop(lamp, "shadow_ray_samples_x", text="Samples X")
-                    sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y")
+                    sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples X"))
+                    sub.prop(lamp, "shadow_ray_samples_y", text=_("Samples Y"))
 
             col.row().prop(lamp, "shadow_ray_sample_method", expand=True)
 
             if lamp.shadow_ray_sample_method == 'ADAPTIVE_QMC':
-                layout.prop(lamp, "shadow_adaptive_threshold", text="Threshold")
+                layout.prop(lamp, "shadow_adaptive_threshold", text=_("Threshold"))
 
             if lamp.type == 'AREA' and lamp.shadow_ray_sample_method == 'CONSTANT_JITTERED':
                 row = layout.row()
@@ -263,44 +263,44 @@ class DATA_PT_shadow(DataButtonsPanel, Panel):
 
         elif lamp.shadow_method == 'BUFFER_SHADOW':
             col = layout.column()
-            col.label(text="Buffer Type:")
+            col.label(text=_("Buffer Type:"))
             col.row().prop(lamp, "shadow_buffer_type", expand=True)
 
             if lamp.shadow_buffer_type in {'REGULAR', 'HALFWAY', 'DEEP'}:
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Filter Type:")
+                col.label(text=_("Filter Type:"))
                 col.prop(lamp, "shadow_filter_type", text="")
                 sub = col.column(align=True)
-                sub.prop(lamp, "shadow_buffer_soft", text="Soft")
-                sub.prop(lamp, "shadow_buffer_bias", text="Bias")
+                sub.prop(lamp, "shadow_buffer_soft", text=_("Soft"))
+                sub.prop(lamp, "shadow_buffer_bias", text=_("Bias"))
 
                 col = split.column()
-                col.label(text="Sample Buffers:")
+                col.label(text=_("Sample Buffers:"))
                 col.prop(lamp, "shadow_sample_buffers", text="")
                 sub = col.column(align=True)
-                sub.prop(lamp, "shadow_buffer_size", text="Size")
-                sub.prop(lamp, "shadow_buffer_samples", text="Samples")
+                sub.prop(lamp, "shadow_buffer_size", text=_("Size"))
+                sub.prop(lamp, "shadow_buffer_samples", text=_("Samples"))
                 if lamp.shadow_buffer_type == 'DEEP':
                     col.prop(lamp, "compression_threshold")
 
             elif lamp.shadow_buffer_type == 'IRREGULAR':
-                layout.prop(lamp, "shadow_buffer_bias", text="Bias")
+                layout.prop(lamp, "shadow_buffer_bias", text=_("Bias"))
 
             split = layout.split()
 
             col = split.column()
-            col.prop(lamp, "use_auto_clip_start", text="Autoclip Start")
+            col.prop(lamp, "use_auto_clip_start", text=_("Autoclip Start"))
             sub = col.column()
             sub.active = not lamp.use_auto_clip_start
-            sub.prop(lamp, "shadow_buffer_clip_start", text="Clip Start")
+            sub.prop(lamp, "shadow_buffer_clip_start", text=_("Clip Start"))
 
             col = split.column()
-            col.prop(lamp, "use_auto_clip_end", text="Autoclip End")
+            col.prop(lamp, "use_auto_clip_end", text=_("Autoclip End"))
             sub = col.column()
             sub.active = not lamp.use_auto_clip_end
-            sub.prop(lamp, "shadow_buffer_clip_end", text=" Clip End")
+            sub.prop(lamp, "shadow_buffer_clip_end", text=_(" Clip End"))
 
 
 class DATA_PT_area(DataButtonsPanel, Panel):
@@ -325,8 +325,8 @@ class DATA_PT_area(DataButtonsPanel, Panel):
         if (lamp.shape == 'SQUARE'):
             sub.prop(lamp, "size")
         elif (lamp.shape == 'RECTANGLE'):
-            sub.prop(lamp, "size", text="Size X")
-            sub.prop(lamp, "size_y", text="Size Y")
+            sub.prop(lamp, "size", text=_("Size X"))
+            sub.prop(lamp, "size_y", text=_("Size Y"))
 
 
 class DATA_PT_spot(DataButtonsPanel, Panel):
@@ -348,8 +348,8 @@ class DATA_PT_spot(DataButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column()
-        sub.prop(lamp, "spot_size", text="Size")
-        sub.prop(lamp, "spot_blend", text="Blend", slider=True)
+        sub.prop(lamp, "spot_size", text=_("Size"))
+        sub.prop(lamp, "spot_blend", text=_("Blend"), slider=True)
         col.prop(lamp, "use_square")
         col.prop(lamp, "show_cone")
 
@@ -358,9 +358,9 @@ class DATA_PT_spot(DataButtonsPanel, Panel):
         col.prop(lamp, "use_halo")
         sub = col.column(align=True)
         sub.active = lamp.use_halo
-        sub.prop(lamp, "halo_intensity", text="Intensity")
+        sub.prop(lamp, "halo_intensity", text=_("Intensity"))
         if lamp.shadow_method == 'BUFFER_SHADOW':
-            sub.prop(lamp, "halo_step", text="Step")
+            sub.prop(lamp, "halo_step", text=_("Step"))
 
 
 class DATA_PT_falloff_curve(DataButtonsPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_data_mesh.py b/release/scripts/startup/bl_ui/properties_data_mesh.py
index ff19ece8f94..37c91370979 100644
--- a/release/scripts/startup/bl_ui/properties_data_mesh.py
+++ b/release/scripts/startup/bl_ui/properties_data_mesh.py
@@ -20,10 +20,10 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class MESH_MT_vertex_group_specials(Menu):
-    bl_label = "Vertex Group Specials"
+    bl_label = _("Vertex Group Specials")
     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def draw(self, context):
@@ -34,7 +34,7 @@ class MESH_MT_vertex_group_specials(Menu):
         layout.operator("object.vertex_group_copy_to_linked", icon='LINK_AREA')
         layout.operator("object.vertex_group_copy_to_selected", icon='LINK_AREA')
         layout.operator("object.vertex_group_mirror", icon='ARROW_LEFTRIGHT')
-        layout.operator("object.vertex_group_remove", icon='X', text="Delete All").all = True
+        layout.operator("object.vertex_group_remove", icon='X', text=_("Delete All")).all = True
         layout.separator()
         layout.operator("object.vertex_group_lock", icon='LOCK', text="Lock All").action = 'SELECT'
         layout.operator("object.vertex_group_lock", icon='UNLOCK', text="UnLock All").action = 'DESELECT'
@@ -51,7 +51,7 @@ class MESH_MT_shape_key_specials(Menu):
         layout.operator("object.shape_key_transfer", icon='COPY_ID')  # icon is not ideal
         layout.operator("object.join_shapes", icon='COPY_ID')  # icon is not ideal
         layout.operator("object.shape_key_mirror", icon='ARROW_LEFTRIGHT')
-        op = layout.operator("object.shape_key_add", icon='ZOOMIN', text="New Shape From Mix")
+        op = layout.operator("object.shape_key_add", icon='ZOOMIN', text=_("New Shape From Mix"))
         op.from_mix = True
 
 
@@ -99,7 +99,7 @@ class DATA_PT_normals(MeshButtonsPanel, Panel):
         col.prop(mesh, "use_auto_smooth")
         sub = col.column()
         sub.active = mesh.use_auto_smooth
-        sub.prop(mesh, "auto_smooth_angle", text="Angle")
+        sub.prop(mesh, "auto_smooth_angle", text=_("Angle"))
 
         split.prop(mesh, "show_double_sided")
 
@@ -120,8 +120,8 @@ class DATA_PT_texture_space(MeshButtonsPanel, Panel):
 
         layout.prop(mesh, "use_auto_texspace")
         row = layout.row()
-        row.column().prop(mesh, "texspace_location", text="Location")
-        row.column().prop(mesh, "texspace_size", text="Size")
+        row.column().prop(mesh, "texspace_location", text=_("Location"))
+        row.column().prop(mesh, "texspace_size", text=_("Size"))
 
 
 class DATA_PT_vertex_groups(MeshButtonsPanel, Panel):
@@ -163,14 +163,14 @@ class DATA_PT_vertex_groups(MeshButtonsPanel, Panel):
             row = layout.row()
 
             sub = row.row(align=True)
-            sub.operator("object.vertex_group_assign", text="Assign")
-            sub.operator("object.vertex_group_remove_from", text="Remove")
+            sub.operator("object.vertex_group_assign", text=_("Assign"))
+            sub.operator("object.vertex_group_remove_from", text=_("Remove"))
 
             sub = row.row(align=True)
-            sub.operator("object.vertex_group_select", text="Select")
-            sub.operator("object.vertex_group_deselect", text="Deselect")
+            sub.operator("object.vertex_group_select", text=_("Select"))
+            sub.operator("object.vertex_group_deselect", text=_("Deselect"))
 
-            layout.prop(context.tool_settings, "vertex_group_weight", text="Weight")
+            layout.prop(context.tool_settings, "vertex_group_weight", text=_("Weight"))
 
 
 class DATA_PT_shape_keys(MeshButtonsPanel, Panel):
@@ -250,13 +250,13 @@ class DATA_PT_shape_keys(MeshButtonsPanel, Panel):
 
                     col = split.column(align=True)
                     col.active = enable_edit_value
-                    col.label(text="Range:")
-                    col.prop(kb, "slider_min", text="Min")
-                    col.prop(kb, "slider_max", text="Max")
+                    col.label(text=_("Range:"))
+                    col.prop(kb, "slider_min", text=_("Min"))
+                    col.prop(kb, "slider_max", text=_("Max"))
 
                     col = split.column(align=True)
                     col.active = enable_edit_value
-                    col.label(text="Blend:")
+                    col.label(text=_("Blend:"))
                     col.prop_search(kb, "vertex_group", ob, "vertex_groups", text="")
                     col.prop_search(kb, "relative_key", key, "key_blocks", text="")
 
diff --git a/release/scripts/startup/bl_ui/properties_data_metaball.py b/release/scripts/startup/bl_ui/properties_data_metaball.py
index cd894e60dbb..693cb697544 100644
--- a/release/scripts/startup/bl_ui/properties_data_metaball.py
+++ b/release/scripts/startup/bl_ui/properties_data_metaball.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class DataButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -60,16 +60,16 @@ class DATA_PT_metaball(DataButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Resolution:")
+        col.label(text=_("Resolution:"))
         sub = col.column(align=True)
-        sub.prop(mball, "resolution", text="View")
-        sub.prop(mball, "render_resolution", text="Render")
+        sub.prop(mball, "resolution", text=_("View"))
+        sub.prop(mball, "render_resolution", text=_("Render"))
 
         col = split.column()
-        col.label(text="Settings:")
-        col.prop(mball, "threshold", text="Threshold")
+        col.label(text=_("Settings:"))
+        col.prop(mball, "threshold", text=_("Threshold"))
 
-        layout.label(text="Update:")
+        layout.label(text=_("Update:"))
         layout.prop(mball, "update_method", expand=True)
 
 
@@ -86,8 +86,8 @@ class DATA_PT_mball_texture_space(DataButtonsPanel, Panel):
         layout.prop(mball, "use_auto_texspace")
 
         row = layout.row()
-        row.column().prop(mball, "texspace_location", text="Location")
-        row.column().prop(mball, "texspace_size", text="Size")
+        row.column().prop(mball, "texspace_location", text=_("Location"))
+        row.column().prop(mball, "texspace_size", text=_("Size"))
 
 
 class DATA_PT_metaball_element(DataButtonsPanel, Panel):
@@ -107,25 +107,25 @@ class DATA_PT_metaball_element(DataButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text="Settings:")
-        col.prop(metaelem, "stiffness", text="Stiffness")
-        col.prop(metaelem, "use_negative", text="Negative")
-        col.prop(metaelem, "hide", text="Hide")
+        col.label(text=_("Settings:"))
+        col.prop(metaelem, "stiffness", text=_("Stiffness"))
+        col.prop(metaelem, "use_negative", text=_("Negative"))
+        col.prop(metaelem, "hide", text=_("Hide"))
 
         col = split.column(align=True)
 
         if metaelem.type in {'CUBE', 'ELLIPSOID'}:
-            col.label(text="Size:")
+            col.label(text=_("Size:"))
             col.prop(metaelem, "size_x", text="X")
             col.prop(metaelem, "size_y", text="Y")
             col.prop(metaelem, "size_z", text="Z")
 
         elif metaelem.type == 'TUBE':
-            col.label(text="Size:")
+            col.label(text=_("Size:"))
             col.prop(metaelem, "size_x", text="X")
 
         elif metaelem.type == 'PLANE':
-            col.label(text="Size:")
+            col.label(text=_("Size:"))
             col.prop(metaelem, "size_x", text="X")
             col.prop(metaelem, "size_y", text="Y")
 
diff --git a/release/scripts/startup/bl_ui/properties_data_modifier.py b/release/scripts/startup/bl_ui/properties_data_modifier.py
index f0904ca8976..32324411669 100644
--- a/release/scripts/startup/bl_ui/properties_data_modifier.py
+++ b/release/scripts/startup/bl_ui/properties_data_modifier.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 class ModifierButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -51,14 +51,14 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Object:")
+        col.label(text=_("Object:"))
         col.prop(md, "object", text="")
         col.prop(md, "use_deform_preserve_volume")
 
         col = split.column()
-        col.label(text="Bind To:")
-        col.prop(md, "use_vertex_groups", text="Vertex Groups")
-        col.prop(md, "use_bone_envelopes", text="Bone Envelopes")
+        col.label(text=_("Bind To:"))
+        col.prop(md, "use_vertex_groups", text=_("Vertex Groups"))
+        col.prop(md, "use_bone_envelopes", text=_("Bone Envelopes"))
 
         layout.separator()
 
@@ -92,11 +92,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         col.separator()
 
-        col.prop(md, "use_merge_vertices", text="Merge")
+        col.prop(md, "use_merge_vertices", text=_("Merge"))
         sub = col.column()
         sub.active = md.use_merge_vertices
-        sub.prop(md, "use_merge_vertices_cap", text="First Last")
-        sub.prop(md, "merge_threshold", text="Distance")
+        sub.prop(md, "use_merge_vertices_cap", text=_("First Last"))
+        sub.prop(md, "merge_threshold", text=_("Distance"))
 
         col = split.column()
         col.prop(md, "use_relative_offset")
@@ -122,7 +122,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split.prop(md, "width")
         split.prop(md, "use_only_vertices")
 
-        layout.label(text="Limit Method:")
+        layout.label(text=_("Limit Method:"))
         layout.row().prop(md, "limit_method", expand=True)
         if md.limit_method == 'ANGLE':
             layout.prop(md, "angle_limit")
@@ -133,11 +133,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Operation:")
+        col.label(text=_("Operation:"))
         col.prop(md, "operation", text="")
 
         col = split.column()
-        col.label(text="Object:")
+        col.label(text=_("Object:"))
         col.prop(md, "object", text="")
 
     def BUILD(self, layout, ob, md):
@@ -156,7 +156,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
     def CAST(self, layout, ob, md):
         split = layout.split(percentage=0.25)
 
-        split.label(text="Cast Type:")
+        split.label(text=_("Cast Type:"))
         split.prop(md, "cast_type", text="")
 
         split = layout.split(percentage=0.25)
@@ -175,52 +175,52 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
         col = split.column()
-        col.label(text="Control Object:")
+        col.label(text=_("Control Object:"))
         col.prop(md, "object", text="")
         if md.object:
             col.prop(md, "use_transform")
 
     def CLOTH(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Physics context")
+        layout.label(text=_("Settings can be found inside the Physics context"))
 
     def COLLISION(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Physics context")
+        layout.label(text=_("Settings can be found inside the Physics context"))
 
     def CURVE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Object:")
+        col.label(text=_("Object:"))
         col.prop(md, "object", text="")
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
-        layout.label(text="Deformation Axis:")
+        layout.label(text=_("Deformation Axis:"))
         layout.row().prop(md, "deform_axis", expand=True)
 
     def DECIMATE(self, layout, ob, md):
         layout.prop(md, "ratio")
-        layout.label(text="Face Count: %s" % str(md.face_count))
+        layout.label(text=_("Face Count")+": %s" % str(md.face_count))
 
     def DISPLACE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Texture:")
+        col.label(text=_("Texture:"))
         col.template_ID(md, "texture", new="texture.new")
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         col = split.column()
-        col.label(text="Direction:")
+        col.label(text=_("Direction:"))
         col.prop(md, "direction", text="")
-        col.label(text="Texture Coordinates:")
+        col.label(text=_("Texture Coordinates:"))
         col.prop(md, "texture_coords", text="")
         if md.texture_coords == 'OBJECT':
-            layout.prop(md, "texture_coords_object", text="Object")
+            layout.prop(md, "texture_coords_object", text=_("Object"))
         elif md.texture_coords == 'UV' and ob.type == 'MESH':
             layout.prop_search(md, "uv_layer", ob.data, "uv_textures")
 
@@ -234,23 +234,23 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(md, "use_edge_angle", text="Edge Angle")
+        col.prop(md, "use_edge_angle", text=_("Edge Angle"))
         sub = col.column()
         sub.active = md.use_edge_angle
         sub.prop(md, "split_angle")
 
-        split.prop(md, "use_edge_sharp", text="Sharp Edges")
+        split.prop(md, "use_edge_sharp", text=_("Sharp Edges"))
 
     def EXPLODE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Vertex group:")
+        col.label(text=_("Vertex group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
         sub = col.column()
         sub.active = bool(md.vertex_group)
         sub.prop(md, "protect")
-        col.label(text="Particle UV")
+        col.label(text=_("Particle UV"))
         col.prop_search(md, "particle_uv", ob.data, "uv_textures", text="")
 
         col = split.column()
@@ -260,22 +260,22 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "show_dead")
         col.prop(md, "use_size")
 
-        layout.operator("object.explode_refresh", text="Refresh")
+        layout.operator("object.explode_refresh", text=_("Refresh"))
 
     def FLUID_SIMULATION(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Physics context")
+        layout.label(text=_("Settings can be found inside the Physics context"))
 
     def HOOK(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Object:")
+        col.label(text=_("Object:"))
         col.prop(md, "object", text="")
         if md.object and md.object.type == 'ARMATURE':
-            col.label(text="Bone:")
+            col.label(text=_("Bone:"))
             col.prop_search(md, "subtarget", md.object.data, "bones", text="")
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         layout.separator()
@@ -287,38 +287,38 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "force", slider=True)
 
         col = split.column()
-        col.operator("object.hook_reset", text="Reset")
-        col.operator("object.hook_recenter", text="Recenter")
+        col.operator("object.hook_reset", text=_("Reset"))
+        col.operator("object.hook_recenter", text=_("Recenter"))
 
         if ob.mode == 'EDIT':
             layout.separator()
             row = layout.row()
-            row.operator("object.hook_select", text="Select")
-            row.operator("object.hook_assign", text="Assign")
+            row.operator("object.hook_select", text=_("Select"))
+            row.operator("object.hook_assign", text=_("Assign"))
 
     def LATTICE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Object:")
+        col.label(text=_("Object:"))
         col.prop(md, "object", text="")
 
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
     def MASK(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Mode:")
+        col.label(text=_("Mode:"))
         col.prop(md, "mode", text="")
         col = split.column()
         if md.mode == 'ARMATURE':
-            col.label(text="Armature:")
+            col.label(text=_("Armature:"))
             col.prop(md, "armature", text="")
         elif md.mode == 'VERTEX_GROUP':
-            col.label(text="Vertex Group:")
+            col.label(text=_("Vertex Group:"))
             col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         sub = col.column()
@@ -330,11 +330,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column()
-        sub.label(text="Object:")
+        sub.label(text=_("Object:"))
         sub.prop(md, "object", text="")
         sub.active = not md.is_bound
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         sub = col.column()
@@ -344,9 +344,9 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         layout.separator()
 
         if md.is_bound:
-            layout.operator("object.meshdeform_bind", text="Unbind")
+            layout.operator("object.meshdeform_bind", text=_("Unbind"))
         else:
-            layout.operator("object.meshdeform_bind", text="Bind")
+            layout.operator("object.meshdeform_bind", text=_("Bind"))
 
             row = layout.row()
             row.prop(md, "precision")
@@ -356,19 +356,19 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split(percentage=0.25)
 
         col = split.column()
-        col.label(text="Axis:")
+        col.label(text=_("Axis:"))
         col.prop(md, "use_x")
         col.prop(md, "use_y")
         col.prop(md, "use_z")
 
         col = split.column()
-        col.label(text="Options:")
-        col.prop(md, "use_mirror_merge", text="Merge")
-        col.prop(md, "use_clip", text="Clipping")
-        col.prop(md, "use_mirror_vertex_groups", text="Vertex Groups")
+        col.label(text=_("Options:"))
+        col.prop(md, "use_mirror_merge", text=_("Merge"))
+        col.prop(md, "use_clip", text=_("Clipping"))
+        col.prop(md, "use_mirror_vertex_groups", text=_("Vertex Groups"))
 
         col = split.column()
-        col.label(text="Textures:")
+        col.label(text=_("Textures:"))
         col.prop(md, "use_mirror_u", text="U")
         col.prop(md, "use_mirror_v", text="V")
 
@@ -376,7 +376,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         if md.use_mirror_merge == True:
             col.prop(md, "merge_threshold")
-        col.label(text="Mirror Object:")
+        col.label(text=_("Mirror Object:"))
         col.prop(md, "mirror_object", text="")
 
     def NAVMESH(self, layout, ob, md):
@@ -388,17 +388,17 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         split = layout.split()
         col = split.column()
-        col.prop(md, "levels", text="Preview")
-        col.prop(md, "sculpt_levels", text="Sculpt")
-        col.prop(md, "render_levels", text="Render")
+        col.prop(md, "levels", text=_("Preview"))
+        col.prop(md, "sculpt_levels", text=_("Sculpt"))
+        col.prop(md, "render_levels", text=_("Render"))
 
         col = split.column()
 
         col.enabled = ob.mode != 'EDIT'
-        col.operator("object.multires_subdivide", text="Subdivide")
-        col.operator("object.multires_higher_levels_delete", text="Delete Higher")
-        col.operator("object.multires_reshape", text="Reshape")
-        col.operator("object.multires_base_apply", text="Apply Base")
+        col.operator("object.multires_subdivide", text=_("Subdivide"))
+        col.operator("object.multires_higher_levels_delete", text=_("Delete Higher"))
+        col.operator("object.multires_reshape", text=_("Reshape"))
+        col.operator("object.multires_base_apply", text=_("Apply Base"))
         col.prop(md, "use_subsurf_uv")
         col.prop(md, "show_only_control_edges")
 
@@ -407,34 +407,34 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col = layout.column()
         row = col.row()
         if md.is_external:
-            row.operator("object.multires_external_pack", text="Pack External")
+            row.operator("object.multires_external_pack", text=_("Pack External"))
             row.label()
             row = col.row()
             row.prop(md, "filepath", text="")
         else:
-            row.operator("object.multires_external_save", text="Save External...")
+            row.operator("object.multires_external_save", text=_("Save External..."))
             row.label()
 
     def PARTICLE_INSTANCE(self, layout, ob, md):
         layout.prop(md, "object")
-        layout.prop(md, "particle_system_index", text="Particle System")
+        layout.prop(md, "particle_system_index", text=_("Particle System"))
 
         split = layout.split()
         col = split.column()
-        col.label(text="Create From:")
+        col.label(text=_("Create From:"))
         col.prop(md, "use_normal")
         col.prop(md, "use_children")
         col.prop(md, "use_size")
 
         col = split.column()
-        col.label(text="Show Particles When:")
+        col.label(text=_("Show Particles When:"))
         col.prop(md, "show_alive")
         col.prop(md, "show_unborn")
         col.prop(md, "show_dead")
 
         layout.separator()
 
-        layout.prop(md, "use_path", text="Create Along Paths")
+        layout.prop(md, "use_path", text=_("Create Along Paths"))
 
         split = layout.split()
         split.active = md.use_path
@@ -444,17 +444,17 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         col = split.column()
         col.prop(md, "position", slider=True)
-        col.prop(md, "random_position", text="Random", slider=True)
+        col.prop(md, "random_position", text=_("Random"), slider=True)
 
     def PARTICLE_SYSTEM(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Particle context")
+        layout.label(text=_("Settings can be found inside the Particle context"))
 
     def SCREW(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
         col.prop(md, "axis")
-        col.prop(md, "object", text="AxisOb")
+        col.prop(md, "object", text=_("AxisOb"))
         col.prop(md, "angle")
         col.prop(md, "steps")
         col.prop(md, "render_steps")
@@ -473,10 +473,10 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
     def SHRINKWRAP(self, layout, ob, md):
         split = layout.split()
         col = split.column()
-        col.label(text="Target:")
+        col.label(text=_("Target:"))
         col.prop(md, "target", text="")
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         split = layout.split()
@@ -486,28 +486,28 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "subsurf_levels")
 
         col = split.column()
-        col.label(text="Mode:")
+        col.label(text=_("Mode:"))
         col.prop(md, "wrap_method", text="")
 
         if md.wrap_method == 'PROJECT':
             split = layout.split(percentage=0.25)
 
             col = split.column()
-            col.label(text="Axis:")
+            col.label(text=_("Axis:"))
             col.prop(md, "use_project_x")
             col.prop(md, "use_project_y")
             col.prop(md, "use_project_z")
 
             col = split.column()
-            col.label(text="Direction:")
+            col.label(text=_("Direction:"))
             col.prop(md, "use_negative_direction")
             col.prop(md, "use_positive_direction")
 
             col = split.column()
-            col.label(text="Cull Faces:")
+            col.label(text=_("Cull Faces:"))
             col.prop(md, "cull_face", expand=True)
 
-            layout.label(text="Auxiliary Target:")
+            layout.label(text=_("Auxiliary Target:"))
             layout.prop(md, "auxiliary_target", text="")
 
         elif md.wrap_method == 'NEAREST_SURFACEPOINT':
@@ -517,24 +517,24 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Mode:")
+        col.label(text=_("Mode:"))
         col.prop(md, "deform_method", text="")
 
         col = split.column()
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         split = layout.split()
 
         col = split.column()
-        col.label(text="Origin:")
+        col.label(text=_("Origin:"))
         col.prop(md, "origin", text="")
         sub = col.column()
         sub.active = (md.origin is not None)
         sub.prop(md, "use_relative")
 
         col = split.column()
-        col.label(text="Deform:")
+        col.label(text=_("Deform:"))
         col.prop(md, "factor")
         col.prop(md, "limits", slider=True)
         if md.deform_method in {'TAPER', 'STRETCH'}:
@@ -542,13 +542,13 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
             col.prop(md, "lock_y")
 
     def SMOKE(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Physics context")
+        layout.label(text=_("Settings can be found inside the Physics context"))
 
     def SMOOTH(self, layout, ob, md):
         split = layout.split(percentage=0.25)
 
         col = split.column()
-        col.label(text="Axis:")
+        col.label(text=_("Axis:"))
         col.prop(md, "use_x")
         col.prop(md, "use_y")
         col.prop(md, "use_z")
@@ -556,11 +556,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col = split.column()
         col.prop(md, "factor")
         col.prop(md, "iterations")
-        col.label(text="Vertex Group:")
+        col.label(text=_("Vertex Group:"))
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
     def SOFT_BODY(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Physics context")
+        layout.label(text=_("Settings can be found inside the Physics context"))
 
     def SOLIDIFY(self, layout, ob, md):
         split = layout.split()
@@ -569,19 +569,19 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "thickness")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
-        col.label(text="Crease:")
-        col.prop(md, "edge_crease_inner", text="Inner")
-        col.prop(md, "edge_crease_outer", text="Outer")
-        col.prop(md, "edge_crease_rim", text="Rim")
-        col.label(text="Material Index Offset:")
+        col.label(text=_("Crease:"))
+        col.prop(md, "edge_crease_inner", text=_("Inner"))
+        col.prop(md, "edge_crease_outer", text=_("Outer"))
+        col.prop(md, "edge_crease_rim", text=_("Rim"))
+        col.label(text=_("Material Index Offset:"))
 
         col = split.column()
 
         col.prop(md, "offset")
         sub = col.column()
         sub.active = bool(md.vertex_group)
-        sub.prop(md, "invert_vertex_group", text="Invert")
-        sub.prop(md, "thickness_vertex_group", text="Factor")
+        sub.prop(md, "invert_vertex_group", text=_("Invert"))
+        sub.prop(md, "thickness_vertex_group", text=_("Factor"))
 
         col.prop(md, "use_even_offset")
         col.prop(md, "use_quality_normals")
@@ -592,64 +592,64 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         row.prop(md, "material_offset", text="")
         row = row.row()
         row.active = md.use_rim
-        row.prop(md, "material_offset_rim", text="Rim")
+        row.prop(md, "material_offset_rim", text=_("Rim"))
 
     def SUBSURF(self, layout, ob, md):
         layout.row().prop(md, "subdivision_type", expand=True)
 
         split = layout.split()
         col = split.column()
-        col.label(text="Subdivisions:")
-        col.prop(md, "levels", text="View")
-        col.prop(md, "render_levels", text="Render")
+        col.label(text=_("Subdivisions:"))
+        col.prop(md, "levels", text=_("View"))
+        col.prop(md, "render_levels", text=_("Render"))
 
         col = split.column()
-        col.label(text="Options:")
+        col.label(text=_("Options:"))
         col.prop(md, "use_subsurf_uv")
         col.prop(md, "show_only_control_edges")
 
     def SURFACE(self, layout, ob, md):
-        layout.label(text="Settings can be found inside the Physics context")
+        layout.label(text=_("Settings can be found inside the Physics context"))
 
     def UV_PROJECT(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Image:")
+        col.label(text=_("Image:"))
         col.prop(md, "image", text="")
 
         col = split.column()
-        col.label(text="UV Layer:")
+        col.label(text=_("UV Layer:"))
         col.prop_search(md, "uv_layer", ob.data, "uv_textures", text="")
 
         split = layout.split()
         col = split.column()
         col.prop(md, "use_image_override")
-        col.prop(md, "projector_count", text="Projectors")
+        col.prop(md, "projector_count", text=_("Projectors"))
         for proj in md.projectors:
             col.prop(proj, "object", text="")
 
         col = split.column()
         sub = col.column(align=True)
-        sub.prop(md, "aspect_x", text="Aspect X")
-        sub.prop(md, "aspect_y", text="Aspect Y")
+        sub.prop(md, "aspect_x", text=_("Aspect X"))
+        sub.prop(md, "aspect_y", text=_("Aspect Y"))
 
         sub = col.column(align=True)
-        sub.prop(md, "scale_x", text="Scale X")
-        sub.prop(md, "scale_y", text="Scale Y")
+        sub.prop(md, "scale_x", text=_("Scale X"))
+        sub.prop(md, "scale_y", text=_("Scale Y"))
 
     def WARP(self, layout, ob, md):
         use_falloff = (md.falloff_type != 'NONE')
         split = layout.split()
 
         col = split.column()
-        col.label(text="From:")
+        col.label(text=_("From:"))
         col.prop(md, "object_from", text="")
 
         col.prop(md, "use_volume_preserve")
 
         col = split.column()
-        col.label(text="To:")
+        col.label(text=_("To:"))
         col.prop(md, "object_to", text="")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
@@ -668,15 +668,15 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         # 2 new columns
         split = layout.split()
         col = split.column()
-        col.label(text="Texture:")
+        col.label(text=_("Texture:"))
         col.prop(md, "texture", text="")
 
         col = split.column()
-        col.label(text="Texture Coordinates:")
+        col.label(text=_("Texture Coordinates:"))
         col.prop(md, "texture_coords", text="")
 
         if md.texture_coords == 'OBJECT':
-            layout.prop(md, "texture_coords_object", text="Object")
+            layout.prop(md, "texture_coords_object", text=_("Object"))
         elif md.texture_coords == 'UV' and ob.type == 'MESH':
             layout.prop_search(md, "uv_layer", ob.data, "uv_textures")
 
@@ -684,7 +684,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Motion:")
+        col.label(text=_("Motion:"))
         col.prop(md, "use_x")
         col.prop(md, "use_y")
         col.prop(md, "use_cyclic")
@@ -700,18 +700,18 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Time:")
+        col.label(text=_("Time:"))
         sub = col.column(align=True)
-        sub.prop(md, "time_offset", text="Offset")
-        sub.prop(md, "lifetime", text="Life")
-        col.prop(md, "damping_time", text="Damping")
+        sub.prop(md, "time_offset", text=_("Offset"))
+        sub.prop(md, "lifetime", text=_("Life"))
+        col.prop(md, "damping_time", text=_("Damping"))
 
         col = split.column()
-        col.label(text="Position:")
+        col.label(text=_("Position:"))
         sub = col.column(align=True)
         sub.prop(md, "start_position_x", text="X")
         sub.prop(md, "start_position_y", text="Y")
-        col.prop(md, "falloff_radius", text="Falloff")
+        col.prop(md, "falloff_radius", text=_("Falloff"))
 
         layout.separator()
 
@@ -719,7 +719,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         layout.prop_search(md, "vertex_group", ob, "vertex_groups")
         split = layout.split(percentage=0.33)
         col = split.column()
-        col.label(text="Texture")
+        col.label(text=_("Texture"))
         col = split.column()
         col.template_ID(md, "texture", new="texture.new")
         layout.prop(md, "texture_coords")
diff --git a/release/scripts/startup/bl_ui/properties_game.py b/release/scripts/startup/bl_ui/properties_game.py
index 26b95484b28..95ae54c4597 100644
--- a/release/scripts/startup/bl_ui/properties_game.py
+++ b/release/scripts/startup/bl_ui/properties_game.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 class PhysicsButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -54,7 +54,7 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             col = split.column()
             col.prop(game, "use_actor")
             col.prop(game, "use_ghost")
-            col.prop(ob, "hide_render", text="Invisible")  # out of place but useful
+            col.prop(ob, "hide_render", text=_("Invisible"))  # out of place but useful
 
             col = split.column()
             col.prop(game, "use_material_physics_fh")
@@ -66,7 +66,7 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text="Attributes:")
+            col.label(text=_("Attributes:"))
             col.prop(game, "mass")
             col.prop(game, "radius")
             col.prop(game, "form_factor")
@@ -81,29 +81,29 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text="Velocity:")
+            col.label(text=_("Velocity:"))
             sub = col.column(align=True)
-            sub.prop(game, "velocity_min", text="Minimum")
-            sub.prop(game, "velocity_max", text="Maximum")
+            sub.prop(game, "velocity_min", text=_("Minimum"))
+            sub.prop(game, "velocity_max", text=_("Maximum"))
 
             col = split.column()
-            col.label(text="Damping:")
+            col.label(text=_("Damping:"))
             sub = col.column(align=True)
-            sub.prop(game, "damping", text="Translation", slider=True)
-            sub.prop(game, "rotation_damping", text="Rotation", slider=True)
+            sub.prop(game, "damping", text=_("Translation"), slider=True)
+            sub.prop(game, "rotation_damping", text=_("Rotation"), slider=True)
 
             layout.separator()
 
             split = layout.split()
 
             col = split.column()
-            col.label(text="Lock Translation:")
+            col.label(text=_("Lock Translation:"))
             col.prop(game, "lock_location_x", text="X")
             col.prop(game, "lock_location_y", text="Y")
             col.prop(game, "lock_location_z", text="Z")
 
             col = split.column()
-            col.label(text="Lock Rotation:")
+            col.label(text=_("Lock Rotation:"))
             col.prop(game, "lock_rotation_x", text="X")
             col.prop(game, "lock_rotation_y", text="Y")
             col.prop(game, "lock_rotation_z", text="Z")
@@ -112,21 +112,21 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             col = layout.column()
             col.prop(game, "use_actor")
             col.prop(game, "use_ghost")
-            col.prop(ob, "hide_render", text="Invisible")
+            col.prop(ob, "hide_render", text=_("Invisible"))
 
             layout.separator()
 
             split = layout.split()
 
             col = split.column()
-            col.label(text="Attributes:")
+            col.label(text=_("Attributes:"))
             col.prop(game, "mass")
             col.prop(soft, "weld_threshold")
             col.prop(soft, "location_iterations")
             col.prop(soft, "linear_stiffness", slider=True)
             col.prop(soft, "dynamic_friction", slider=True)
             col.prop(soft, "collision_margin", slider=True)
-            col.prop(soft, "use_bending_constraints", text="Bending Constraints")
+            col.prop(soft, "use_bending_constraints", text=_("Bending Constraints"))
 
             col = split.column()
             col.prop(soft, "use_shape_match")
@@ -136,25 +136,25 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
 
             col.separator()
 
-            col.label(text="Cluster Collision:")
+            col.label(text=_("Cluster Collision:"))
             col.prop(soft, "use_cluster_rigid_to_softbody")
             col.prop(soft, "use_cluster_soft_to_softbody")
             sub = col.column()
             sub.active = (soft.use_cluster_rigid_to_softbody or soft.use_cluster_soft_to_softbody)
-            sub.prop(soft, "cluster_iterations", text="Iterations")
+            sub.prop(soft, "cluster_iterations", text=_("Iterations"))
 
         elif game.physics_type == 'STATIC':
             col = layout.column()
             col.prop(game, "use_actor")
             col.prop(game, "use_ghost")
-            col.prop(ob, "hide_render", text="Invisible")
+            col.prop(ob, "hide_render", text=_("Invisible"))
 
             layout.separator()
 
             split = layout.split()
 
             col = split.column()
-            col.label(text="Attributes:")
+            col.label(text=_("Attributes:"))
             col.prop(game, "radius")
 
             col = split.column()
@@ -165,7 +165,7 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             subsub.prop(game, "friction_coefficients", text="", slider=True)
 
         elif game.physics_type in {'SENSOR', 'INVISIBLE', 'NO_COLLISION', 'OCCLUDE'}:
-            layout.prop(ob, "hide_render", text="Invisible")
+            layout.prop(ob, "hide_render", text=_("Invisible"))
 
 
 class PHYSICS_PT_game_collision_bounds(PhysicsButtonsPanel, Panel):
@@ -189,11 +189,11 @@ class PHYSICS_PT_game_collision_bounds(PhysicsButtonsPanel, Panel):
         game = context.active_object.game
 
         layout.active = game.use_collision_bounds
-        layout.prop(game, "collision_bounds_type", text="Bounds")
+        layout.prop(game, "collision_bounds_type", text=_("Bounds"))
 
         row = layout.row()
-        row.prop(game, "collision_margin", text="Margin", slider=True)
-        row.prop(game, "use_collision_compound", text="Compound")
+        row.prop(game, "collision_margin", text=_("Margin"), slider=True)
+        row.prop(game, "use_collision_compound", text=_("Compound"))
 
 
 class PHYSICS_PT_game_obstacles(PhysicsButtonsPanel, Panel):
@@ -242,7 +242,7 @@ class RENDER_PT_game(RenderButtonsPanel, Panel):
         layout = self.layout
 
         row = layout.row()
-        row.operator("view3d.game_start", text="Start")
+        row.operator("view3d.game_start", text=_("Start"))
         row.label()
 
 
@@ -260,20 +260,20 @@ class RENDER_PT_game_player(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Resolution:")
+        col.label(text=_("Resolution:"))
         sub = col.column(align=True)
         sub.prop(gs, "resolution_x", slider=False, text="X")
         sub.prop(gs, "resolution_y", slider=False, text="Y")
 
         col = split.column()
-        col.label(text="Quality:")
+        col.label(text=_("Quality:"))
         sub = col.column(align=True)
-        sub.prop(gs, "depth", text="Bit Depth", slider=False)
-        sub.prop(gs, "frequency", text="FPS", slider=False)
+        sub.prop(gs, "depth", text=_("Bit Depth"), slider=False)
+        sub.prop(gs, "frequency", text=_("FPS"), slider=False)
 
         # framing:
         col = layout.column()
-        col.label(text="Framing:")
+        col.label(text=_("Framing:"))
         col.row().prop(gs, "frame_type", expand=True)
         if gs.frame_type == 'LETTERBOX':
             col.prop(gs, "frame_color", text="")
@@ -299,7 +299,7 @@ class RENDER_PT_game_stereo(RenderButtonsPanel, Panel):
 
         # dome:
         elif stereo_mode == 'DOME':
-            layout.prop(gs, "dome_mode", text="Dome Type")
+            layout.prop(gs, "dome_mode", text=_("Dome Type"))
 
             dome_type = gs.dome_mode
 
@@ -310,23 +310,23 @@ class RENDER_PT_game_stereo(RenderButtonsPanel, Panel):
                dome_type == 'TRUNCATED_FRONT':
 
                 col = split.column()
-                col.prop(gs, "dome_buffer_resolution", text="Resolution", slider=True)
+                col.prop(gs, "dome_buffer_resolution", text=_("Resolution"), slider=True)
                 col.prop(gs, "dome_angle", slider=True)
 
                 col = split.column()
-                col.prop(gs, "dome_tesselation", text="Tesselation")
+                col.prop(gs, "dome_tesselation", text=_("Tesselation"))
                 col.prop(gs, "dome_tilt")
 
             elif dome_type == 'PANORAM_SPH':
                 col = split.column()
 
-                col.prop(gs, "dome_buffer_resolution", text="Resolution", slider=True)
+                col.prop(gs, "dome_buffer_resolution", text=_("Resolution"), slider=True)
                 col = split.column()
-                col.prop(gs, "dome_tesselation", text="Tesselation")
+                col.prop(gs, "dome_tesselation", text=_("Tesselation"))
 
             else:  # cube map
                 col = split.column()
-                col.prop(gs, "dome_buffer_resolution", text="Resolution", slider=True)
+                col.prop(gs, "dome_buffer_resolution", text=_("Resolution"), slider=True)
 
                 col = split.column()
 
@@ -348,15 +348,15 @@ class RENDER_PT_game_shading(RenderButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.prop(gs, "use_glsl_lights", text="Lights")
-            col.prop(gs, "use_glsl_shaders", text="Shaders")
-            col.prop(gs, "use_glsl_shadows", text="Shadows")
-            col.prop(gs, "use_glsl_color_management", text="Color Management")
+            col.prop(gs, "use_glsl_lights", text=_("Lights"))
+            col.prop(gs, "use_glsl_shaders", text=_("Shaders"))
+            col.prop(gs, "use_glsl_shadows", text=_("Shadows"))
+            col.prop(gs, "use_glsl_color_management", text=_("Color Management"))
 
             col = split.column()
-            col.prop(gs, "use_glsl_ramps", text="Ramps")
-            col.prop(gs, "use_glsl_nodes", text="Nodes")
-            col.prop(gs, "use_glsl_extra_textures", text="Extra Textures")
+            col.prop(gs, "use_glsl_ramps", text=_("Ramps"))
+            col.prop(gs, "use_glsl_nodes", text=_("Nodes"))
+            col.prop(gs, "use_glsl_extra_textures", text=_("Extra Textures"))
 
 
 class RENDER_PT_game_performance(RenderButtonsPanel, Panel):
@@ -384,11 +384,11 @@ class RENDER_PT_game_display(RenderButtonsPanel, Panel):
 
         gs = context.scene.game_settings
         flow = layout.column_flow()
-        flow.prop(gs, "show_debug_properties", text="Debug Properties")
-        flow.prop(gs, "show_framerate_profile", text="Framerate and Profile")
-        flow.prop(gs, "show_physics_visualization", text="Physics Visualization")
+        flow.prop(gs, "show_debug_properties", text=_("Debug Properties"))
+        flow.prop(gs, "show_framerate_profile", text=_("Framerate and Profile"))
+        flow.prop(gs, "show_physics_visualization", text=_("Physics Visualization"))
         flow.prop(gs, "use_deprecation_warnings")
-        flow.prop(gs, "show_mouse", text="Mouse Cursor")
+        flow.prop(gs, "show_mouse", text=_("Mouse Cursor"))
 
 
 class SceneButtonsPanel():
@@ -546,37 +546,37 @@ class WORLD_PT_game_physics(WorldButtonsPanel, Panel):
 
         layout.prop(gs, "physics_engine")
         if gs.physics_engine != 'NONE':
-            layout.prop(gs, "physics_gravity", text="Gravity")
+            layout.prop(gs, "physics_gravity", text=_("Gravity"))
 
             split = layout.split()
 
             col = split.column()
-            col.label(text="Physics Steps:")
+            col.label(text=_("Physics Steps:"))
             sub = col.column(align=True)
-            sub.prop(gs, "physics_step_max", text="Max")
-            sub.prop(gs, "physics_step_sub", text="Substeps")
-            col.prop(gs, "fps", text="FPS")
+            sub.prop(gs, "physics_step_max", text=_("Max"))
+            sub.prop(gs, "physics_step_sub", text=_("Substeps"))
+            col.prop(gs, "fps", text=_("FPS"))
 
             col = split.column()
-            col.label(text="Logic Steps:")
-            col.prop(gs, "logic_step_max", text="Max")
+            col.label(text=_("Logic Steps:"))
+            col.prop(gs, "logic_step_max", text=_("Max"))
 
             col = layout.column()
-            col.prop(gs, "use_occlusion_culling", text="Occlusion Culling")
+            col.prop(gs, "use_occlusion_culling", text=_("Occlusion Culling"))
             sub = col.column()
             sub.active = gs.use_occlusion_culling
-            sub.prop(gs, "occlusion_culling_resolution", text="Resolution")
+            sub.prop(gs, "occlusion_culling_resolution", text=_("Resolution"))
 
         else:
             split = layout.split()
 
             col = split.column()
-            col.label(text="Physics Steps:")
-            col.prop(gs, "fps", text="FPS")
+            col.label(text=_("Physics Steps:"))
+            col.prop(gs, "fps", text=_("FPS"))
 
             col = split.column()
-            col.label(text="Logic Steps:")
-            col.prop(gs, "logic_step_max", text="Max")
+            col.label(text=_("Logic Steps:"))
+            col.prop(gs, "logic_step_max", text=_("Max"))
 
 
 class WORLD_PT_game_physics_obstacles(WorldButtonsPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_material.py b/release/scripts/startup/bl_ui/properties_material.py
index 68d7d5d4615..7b04c990c6a 100644
--- a/release/scripts/startup/bl_ui/properties_material.py
+++ b/release/scripts/startup/bl_ui/properties_material.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 def active_node_mat(mat):
     # TODO, 2.4x has a pipeline section, for 2.5 we need to communicate
@@ -114,9 +114,9 @@ class MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
 
             if ob.mode == 'EDIT':
                 row = layout.row(align=True)
-                row.operator("object.material_slot_assign", text="Assign")
-                row.operator("object.material_slot_select", text="Select")
-                row.operator("object.material_slot_deselect", text="Deselect")
+                row.operator("object.material_slot_assign", text=_("Assign"))
+                row.operator("object.material_slot_select", text=_("Select"))
+                row.operator("object.material_slot_deselect", text=_("Deselect"))
 
         split = layout.split(percentage=0.65)
 
@@ -142,7 +142,7 @@ class MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
                 if mat.active_node_material:
                     row.prop(mat.active_node_material, "name", text="")
                 else:
-                    row.label(text="No material node selected")
+                    row.label(text=_("No material node selected"))
 
 
 class MATERIAL_PT_preview(MaterialButtonsPanel, Panel):
@@ -197,8 +197,8 @@ class MATERIAL_PT_pipeline(MaterialButtonsPanel, Panel):
         col = split.column()
         col.active = mat_type
 
-        col.prop(mat, "use_cast_shadows_only", text="Cast Only")
-        col.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
+        col.prop(mat, "use_cast_shadows_only", text=_("Cast Only"))
+        col.prop(mat, "shadow_cast_alpha", text=_("Casting Alpha"))
         col.prop(mat, "use_cast_buffer_shadows")
         col.prop(mat, "use_cast_approximate")
         col.prop(mat, "pass_index")
@@ -225,12 +225,12 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
         col.prop(mat, "diffuse_color", text="")
         sub = col.column()
         sub.active = (not mat.use_shadeless)
-        sub.prop(mat, "diffuse_intensity", text="Intensity")
+        sub.prop(mat, "diffuse_intensity", text=_("Intensity"))
 
         col = split.column()
         col.active = (not mat.use_shadeless)
         col.prop(mat, "diffuse_shader", text="")
-        col.prop(mat, "use_diffuse_ramp", text="Ramp")
+        col.prop(mat, "use_diffuse_ramp", text=_("Ramp"))
 
         col = layout.column()
         col.active = (not mat.use_shadeless)
@@ -240,12 +240,12 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
             col.prop(mat, "darkness")
         elif mat.diffuse_shader == 'TOON':
             row = col.row()
-            row.prop(mat, "diffuse_toon_size", text="Size")
-            row.prop(mat, "diffuse_toon_smooth", text="Smooth")
+            row.prop(mat, "diffuse_toon_size", text=_("Size"))
+            row.prop(mat, "diffuse_toon_smooth", text=_("Smooth"))
         elif mat.diffuse_shader == 'FRESNEL':
             row = col.row()
-            row.prop(mat, "diffuse_fresnel", text="Fresnel")
-            row.prop(mat, "diffuse_fresnel_factor", text="Factor")
+            row.prop(mat, "diffuse_fresnel", text=_("Fresnel"))
+            row.prop(mat, "diffuse_fresnel_factor", text=_("Factor"))
 
         if mat.use_diffuse_ramp:
             col = layout.column()
@@ -255,10 +255,10 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
             col.separator()
 
             row = col.row()
-            row.prop(mat, "diffuse_ramp_input", text="Input")
-            row.prop(mat, "diffuse_ramp_blend", text="Blend")
+            row.prop(mat, "diffuse_ramp_input", text=_("Input"))
+            row.prop(mat, "diffuse_ramp_blend", text=_("Blend"))
 
-            col.prop(mat, "diffuse_ramp_factor", text="Factor")
+            col.prop(mat, "diffuse_ramp_factor", text=_("Factor"))
 
 
 class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
@@ -282,25 +282,25 @@ class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
 
         col = split.column()
         col.prop(mat, "specular_color", text="")
-        col.prop(mat, "specular_intensity", text="Intensity")
+        col.prop(mat, "specular_intensity", text=_("Intensity"))
 
         col = split.column()
         col.prop(mat, "specular_shader", text="")
-        col.prop(mat, "use_specular_ramp", text="Ramp")
+        col.prop(mat, "use_specular_ramp", text=_("Ramp"))
 
         col = layout.column()
         if mat.specular_shader in {'COOKTORR', 'PHONG'}:
-            col.prop(mat, "specular_hardness", text="Hardness")
+            col.prop(mat, "specular_hardness", text=_("Hardness"))
         elif mat.specular_shader == 'BLINN':
             row = col.row()
-            row.prop(mat, "specular_hardness", text="Hardness")
-            row.prop(mat, "specular_ior", text="IOR")
+            row.prop(mat, "specular_hardness", text=_("Hardness"))
+            row.prop(mat, "specular_ior", text=_("IOR"))
         elif mat.specular_shader == 'WARDISO':
-            col.prop(mat, "specular_slope", text="Slope")
+            col.prop(mat, "specular_slope", text=_("Slope"))
         elif mat.specular_shader == 'TOON':
             row = col.row()
-            row.prop(mat, "specular_toon_size", text="Size")
-            row.prop(mat, "specular_toon_smooth", text="Smooth")
+            row.prop(mat, "specular_toon_size", text=_("Size"))
+            row.prop(mat, "specular_toon_smooth", text=_("Smooth"))
 
         if mat.use_specular_ramp:
             layout.separator()
@@ -308,10 +308,10 @@ class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
             layout.separator()
 
             row = layout.row()
-            row.prop(mat, "specular_ramp_input", text="Input")
-            row.prop(mat, "specular_ramp_blend", text="Blend")
+            row.prop(mat, "specular_ramp_input", text=_("Input"))
+            row.prop(mat, "specular_ramp_blend", text=_("Blend"))
 
-            layout.prop(mat, "specular_ramp_factor", text="Factor")
+            layout.prop(mat, "specular_ramp_factor", text=_("Factor"))
 
 
 class MATERIAL_PT_shading(MaterialButtonsPanel, Panel):
@@ -384,14 +384,14 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
         col.prop(mat, "alpha")
         row = col.row()
         row.active = (base_mat.transparency_method != 'MASK') and (not mat.use_shadeless)
-        row.prop(mat, "specular_alpha", text="Specular")
+        row.prop(mat, "specular_alpha", text=_("Specular"))
 
         col = split.column()
         col.active = (not mat.use_shadeless)
         col.prop(rayt, "fresnel")
         sub = col.column()
         sub.active = rayt.fresnel > 0
-        sub.prop(rayt, "fresnel_factor", text="Blend")
+        sub.prop(rayt, "fresnel_factor", text=_("Blend"))
 
         if base_mat.transparency_method == 'RAYTRACE':
             layout.separator()
@@ -406,12 +406,12 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
             col.prop(rayt, "depth")
 
             col = split.column()
-            col.label(text="Gloss:")
-            col.prop(rayt, "gloss_factor", text="Amount")
+            col.label(text=_("Gloss:"))
+            col.prop(rayt, "gloss_factor", text=_("Amount"))
             sub = col.column()
             sub.active = rayt.gloss_factor < 1.0
-            sub.prop(rayt, "gloss_threshold", text="Threshold")
-            sub.prop(rayt, "gloss_samples", text="Samples")
+            sub.prop(rayt, "gloss_threshold", text=_("Threshold"))
+            sub.prop(rayt, "gloss_samples", text=_("Samples"))
 
 
 class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
@@ -448,28 +448,28 @@ class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
         col.prop(raym, "fresnel")
         sub = col.column()
         sub.active = raym.fresnel > 0
-        sub.prop(raym, "fresnel_factor", text="Blend")
+        sub.prop(raym, "fresnel_factor", text=_("Blend"))
 
         split = layout.split()
 
         col = split.column()
         col.separator()
         col.prop(raym, "depth")
-        col.prop(raym, "distance", text="Max Dist")
+        col.prop(raym, "distance", text=_("Max Dist"))
         col.separator()
         sub = col.split(percentage=0.4)
         sub.active = raym.distance > 0.0
-        sub.label(text="Fade To:")
+        sub.label(text=_("Fade To:"))
         sub.prop(raym, "fade_to", text="")
 
         col = split.column()
-        col.label(text="Gloss:")
-        col.prop(raym, "gloss_factor", text="Amount")
+        col.label(text=_("Gloss:"))
+        col.prop(raym, "gloss_factor", text=_("Amount"))
         sub = col.column()
         sub.active = raym.gloss_factor < 1.0
-        sub.prop(raym, "gloss_threshold", text="Threshold")
-        sub.prop(raym, "gloss_samples", text="Samples")
-        sub.prop(raym, "gloss_anisotropic", text="Anisotropic")
+        sub.prop(raym, "gloss_threshold", text=_("Threshold"))
+        sub.prop(raym, "gloss_samples", text=_("Samples"))
+        sub.prop(raym, "gloss_anisotropic", text=_("Anisotropic"))
 
 
 class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
@@ -510,18 +510,18 @@ class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
         col.prop(sss, "ior")
         col.prop(sss, "scale")
         col.prop(sss, "color", text="")
-        col.prop(sss, "radius", text="RGB Radius", expand=True)
+        col.prop(sss, "radius", text=_("RGB Radius"), expand=True)
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text="Blend:")
-        sub.prop(sss, "color_factor", text="Color")
-        sub.prop(sss, "texture_factor", text="Texture")
-        sub.label(text="Scattering Weight:")
+        sub.label(text=_("Blend:"))
+        sub.prop(sss, "color_factor", text=_("Color"))
+        sub.prop(sss, "texture_factor", text=_("Texture"))
+        sub.label(text=_("Scattering Weight:"))
         sub.prop(sss, "front")
         sub.prop(sss, "back")
         col.separator()
-        col.prop(sss, "error_threshold", text="Error")
+        col.prop(sss, "error_threshold", text=_("Error"))
 
 
 class MATERIAL_PT_halo(MaterialButtonsPanel, Panel):
@@ -561,7 +561,7 @@ class MATERIAL_PT_halo(MaterialButtonsPanel, Panel):
         col.prop(halo, "hardness")
         col.prop(halo, "add")
 
-        layout.label(text="Options:")
+        layout.label(text=_("Options:"))
 
         split = layout.split()
         col = split.column()
@@ -603,13 +603,13 @@ class MATERIAL_PT_flare(MaterialButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(halo, "flare_size", text="Size")
-        col.prop(halo, "flare_boost", text="Boost")
-        col.prop(halo, "flare_seed", text="Seed")
+        col.prop(halo, "flare_size", text=_("Size"))
+        col.prop(halo, "flare_boost", text=_("Boost"))
+        col.prop(halo, "flare_seed", text=_("Seed"))
 
         col = split.column()
-        col.prop(halo, "flare_subflare_count", text="Subflares")
-        col.prop(halo, "flare_subflare_size", text="Subsize")
+        col.prop(halo, "flare_subflare_count", text=_("Subflares"))
+        col.prop(halo, "flare_subflare_size", text=_("Subsize"))
 
 
 class MATERIAL_PT_game_settings(MaterialButtonsPanel, bpy.types.Panel):
@@ -660,7 +660,7 @@ class MATERIAL_PT_physics(MaterialButtonsPanel, bpy.types.Panel):
         row.prop(phys, "elasticity", slider=True)
 
         row = layout.row()
-        row.label(text="Force Field:")
+        row.label(text=_("Force Field:"))
 
         row = layout.row()
         row.prop(phys, "fh_force")
@@ -692,10 +692,10 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text="Size:")
-        sub.prop(tan, "root_size", text="Root")
-        sub.prop(tan, "tip_size", text="Tip")
-        sub.prop(tan, "size_min", text="Minimum")
+        sub.label(text=_("Size:"))
+        sub.prop(tan, "root_size", text=_("Root"))
+        sub.prop(tan, "tip_size", text=_("Tip"))
+        sub.prop(tan, "size_min", text=_("Minimum"))
         sub.prop(tan, "use_blender_units")
         sub = col.column()
         sub.active = (not mat.use_shadeless)
@@ -703,7 +703,7 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
         col.prop(tan, "shape")
 
         col = split.column()
-        col.label(text="Shading:")
+        col.label(text=_("Shading:"))
         col.prop(tan, "width_fade")
         ob = context.object
         if ob and ob.type == 'MESH':
@@ -713,9 +713,9 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
         col.separator()
         sub = col.column()
         sub.active = (not mat.use_shadeless)
-        sub.label("Surface diffuse:")
+        sub.label(_("Surface diffuse:"))
         sub = col.column()
-        sub.prop(tan, "blend_distance", text="Distance")
+        sub.prop(tan, "blend_distance", text=_("Distance"))
 
 
 class MATERIAL_PT_options(MaterialButtonsPanel, Panel):
@@ -748,11 +748,11 @@ class MATERIAL_PT_options(MaterialButtonsPanel, Panel):
             sub.prop(mat, "offset_z")
             sub.active = mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'
         sub = col.column(align=True)
-        sub.label(text="Light Group:")
+        sub.label(text=_("Light Group:"))
         sub.prop(mat, "light_group", text="")
         row = sub.row()
         row.active = bool(mat.light_group)
-        row.prop(mat, "use_light_group_exclusive", text="Exclusive")
+        row.prop(mat, "use_light_group_exclusive", text=_("Exclusive"))
 
         col = split.column()
         col.prop(mat, "use_face_texture")
@@ -787,12 +787,12 @@ class MATERIAL_PT_shadow(MaterialButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(mat, "use_shadows", text="Receive")
-        col.prop(mat, "use_transparent_shadows", text="Receive Transparent")
+        col.prop(mat, "use_shadows", text=_("Receive"))
+        col.prop(mat, "use_transparent_shadows", text=_("Receive Transparent"))
         if simple_material(base_mat):
-            col.prop(mat, "use_cast_shadows_only", text="Cast Only")
-            col.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
-        col.prop(mat, "use_only_shadow", text="Shadows Only")
+            col.prop(mat, "use_cast_shadows_only", text=_("Cast Only"))
+            col.prop(mat, "shadow_cast_alpha", text=_("Casting Alpha"))
+        col.prop(mat, "use_only_shadow", text=_("Shadows Only"))
         sub = col.column()
         sub.active = mat.use_only_shadow
         sub.prop(mat, "shadow_only_type", text="")
@@ -802,11 +802,11 @@ class MATERIAL_PT_shadow(MaterialButtonsPanel, Panel):
             col.prop(mat, "use_cast_buffer_shadows")
         sub = col.column()
         sub.active = mat.use_cast_buffer_shadows
-        sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias")
-        col.prop(mat, "use_ray_shadow_bias", text="Auto Ray Bias")
+        sub.prop(mat, "shadow_buffer_bias", text=_("Buffer Bias"))
+        col.prop(mat, "use_ray_shadow_bias", text=_("Auto Ray Bias"))
         sub = col.column()
         sub.active = (not mat.use_ray_shadow_bias)
-        sub.prop(mat, "shadow_ray_bias", text="Ray Bias")
+        sub.prop(mat, "shadow_ray_bias", text=_("Ray Bias"))
         if simple_material(base_mat):
             col.prop(mat, "use_cast_approximate")
 
@@ -919,7 +919,7 @@ class MATERIAL_PT_volume_lighting(VolumeButtonsPanel, Panel):
             sub = col.column()
             sub.enabled = True
             sub.active = False
-            sub.label("Light Cache Enabled")
+            sub.label(_("Light Cache Enabled"))
             col.prop(vol, "cache_resolution")
 
             sub = col.column(align=True)
@@ -958,7 +958,7 @@ class MATERIAL_PT_volume_integration(VolumeButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Step Calculation:")
+        col.label(text=_("Step Calculation:"))
         col.prop(vol, "step_method", text="")
         col = col.column(align=True)
         col.prop(vol, "step_size")
@@ -993,11 +993,11 @@ class MATERIAL_PT_volume_options(VolumeButtonsPanel, Panel):
         col.prop(mat, "use_mist")
 
         col = split.column()
-        col.label(text="Light Group:")
+        col.label(text=_("Light Group:"))
         col.prop(mat, "light_group", text="")
         row = col.row()
         row.active = bool(mat.light_group)
-        row.prop(mat, "use_light_group_exclusive", text="Exclusive")
+        row.prop(mat, "use_light_group_exclusive", text=_("Exclusive"))
 
 
 class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_object.py b/release/scripts/startup/bl_ui/properties_object.py
index 0779debb102..a099189eed6 100644
--- a/release/scripts/startup/bl_ui/properties_object.py
+++ b/release/scripts/startup/bl_ui/properties_object.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class ObjectButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -55,14 +55,14 @@ class OBJECT_PT_transform(ObjectButtonsPanel, Panel):
 
         row.column().prop(ob, "location")
         if ob.rotation_mode == 'QUATERNION':
-            row.column().prop(ob, "rotation_quaternion", text="Rotation")
+            row.column().prop(ob, "rotation_quaternion", text=_("Rotation"))
         elif ob.rotation_mode == 'AXIS_ANGLE':
-            #row.column().label(text="Rotation")
-            #row.column().prop(pchan, "rotation_angle", text="Angle")
-            #row.column().prop(pchan, "rotation_axis", text="Axis")
-            row.column().prop(ob, "rotation_axis_angle", text="Rotation")
+            #row.column().label(text=_("Rotation"))
+            #row.column().prop(pchan, "rotation_angle", text=_("Angle"))
+            #row.column().prop(pchan, "rotation_axis", text=_("Axis"))
+            row.column().prop(ob, "rotation_axis_angle", text=_("Rotation"))
         else:
-            row.column().prop(ob, "rotation_euler", text="Rotation")
+            row.column().prop(ob, "rotation_euler", text=_("Rotation"))
 
         row.column().prop(ob, "scale")
 
@@ -82,15 +82,15 @@ class OBJECT_PT_delta_transform(ObjectButtonsPanel, Panel):
 
         row.column().prop(ob, "delta_location")
         if ob.rotation_mode == 'QUATERNION':
-            row.column().prop(ob, "delta_rotation_quaternion", text="Rotation")
+            row.column().prop(ob, "delta_rotation_quaternion", text=_("Rotation"))
         elif ob.rotation_mode == 'AXIS_ANGLE':
-            #row.column().label(text="Rotation")
-            #row.column().prop(pchan, "delta_rotation_angle", text="Angle")
-            #row.column().prop(pchan, "delta_rotation_axis", text="Axis")
-            #row.column().prop(ob, "delta_rotation_axis_angle", text="Rotation")
-            row.column().label(text="Not for Axis-Angle")
+            #row.column().label(text=_("Rotation"))
+            #row.column().prop(pchan, "delta_rotation_angle", text=_("Angle"))
+            #row.column().prop(pchan, "delta_rotation_axis", text=_("Axis"))
+            #row.column().prop(ob, "delta_rotation_axis_angle", text=_("Rotation"))
+            row.column().label(text=_("Not for Axis-Angle"))
         else:
-            row.column().prop(ob, "delta_rotation_euler", text="Rotation")
+            row.column().prop(ob, "delta_rotation_euler", text=_("Rotation"))
 
         row.column().prop(ob, "delta_scale")
 
@@ -107,18 +107,18 @@ class OBJECT_PT_transform_locks(ObjectButtonsPanel, Panel):
         row = layout.row()
 
         col = row.column()
-        col.prop(ob, "lock_location", text="Location")
+        col.prop(ob, "lock_location", text=_("Location"))
 
         col = row.column()
         if ob.rotation_mode in {'QUATERNION', 'AXIS_ANGLE'}:
-            col.prop(ob, "lock_rotations_4d", text="Rotation")
+            col.prop(ob, "lock_rotations_4d", text=_("Rotation"))
             if ob.lock_rotations_4d:
                 col.prop(ob, "lock_rotation_w", text="W")
             col.prop(ob, "lock_rotation", text="")
         else:
-            col.prop(ob, "lock_rotation", text="Rotation")
+            col.prop(ob, "lock_rotation", text=_("Rotation"))
 
-        row.column().prop(ob, "lock_scale", text="Scale")
+        row.column().prop(ob, "lock_scale", text=_("Scale"))
 
 
 class OBJECT_PT_relations(ObjectButtonsPanel, Panel):
@@ -137,7 +137,7 @@ class OBJECT_PT_relations(ObjectButtonsPanel, Panel):
         col.prop(ob, "pass_index")
 
         col = split.column()
-        col.label(text="Parent:")
+        col.label(text=_("Parent:"))
         col.prop(ob, "parent", text="")
 
         sub = col.column()
@@ -157,7 +157,7 @@ class OBJECT_PT_groups(ObjectButtonsPanel, Panel):
         ob = context.object
 
         row = layout.row(align=True)
-        row.operator("object.group_link", text="Add to Group")
+        row.operator("object.group_link", text=_("Add to Group"))
         row.operator("object.group_add", text="", icon='ZOOMIN')
 
         # XXX, this is bad practice, yes, I wrote it :( - campbell
@@ -176,12 +176,12 @@ class OBJECT_PT_groups(ObjectButtonsPanel, Panel):
                 split = col.box().split()
 
                 col = split.column()
-                col.prop(group, "layers", text="Dupli")
+                col.prop(group, "layers", text=_("Dupli"))
 
                 col = split.column()
                 col.prop(group, "dupli_offset", text="")
 
-                prop = col.operator("wm.context_set_value", text="From Cursor")
+                prop = col.operator("wm.context_set_value", text=_("From Cursor"))
                 prop.data_path = "object.users_group[%d].dupli_offset" % index
                 prop.value = value
                 index += 1
@@ -197,11 +197,11 @@ class OBJECT_PT_display(ObjectButtonsPanel, Panel):
 
         split = layout.split()
         col = split.column()
-        col.prop(ob, "draw_type", text="Type")
+        col.prop(ob, "draw_type", text=_("Type"))
 
         col = split.column()
         row = col.row()
-        row.prop(ob, "show_bounds", text="Bounds")
+        row.prop(ob, "show_bounds", text=_("Bounds"))
         sub = row.row()
         sub.active = ob.show_bounds
         sub.prop(ob, "draw_bounds_type", text="")
@@ -209,16 +209,16 @@ class OBJECT_PT_display(ObjectButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(ob, "show_name", text="Name")
-        col.prop(ob, "show_axis", text="Axis")
-        col.prop(ob, "show_wire", text="Wire")
-        col.prop(ob, "color", text="Object Color")
+        col.prop(ob, "show_name", text=_("Name"))
+        col.prop(ob, "show_axis", text=_("Axis"))
+        col.prop(ob, "show_wire", text=_("Wire"))
+        col.prop(ob, "color", text=_("Object Color"))
 
         col = split.column()
-        col.prop(ob, "show_texture_space", text="Texture Space")
-        col.prop(ob, "show_x_ray", text="X-Ray")
+        col.prop(ob, "show_texture_space", text=_("Texture Space"))
+        col.prop(ob, "show_x_ray", text=_("X-Ray"))
         if ob.type == 'MESH':
-            col.prop(ob, "show_transparent", text="Transparency")
+            col.prop(ob, "show_transparent", text=_("Transparency"))
 
 
 class OBJECT_PT_duplication(ObjectButtonsPanel, Panel):
@@ -235,26 +235,26 @@ class OBJECT_PT_duplication(ObjectButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column(align=True)
-            col.prop(ob, "dupli_frames_start", text="Start")
-            col.prop(ob, "dupli_frames_end", text="End")
+            col.prop(ob, "dupli_frames_start", text=_("Start"))
+            col.prop(ob, "dupli_frames_end", text=_("End"))
 
             col = split.column(align=True)
-            col.prop(ob, "dupli_frames_on", text="On")
-            col.prop(ob, "dupli_frames_off", text="Off")
+            col.prop(ob, "dupli_frames_on", text=_("On"))
+            col.prop(ob, "dupli_frames_off", text=_("Off"))
 
-            layout.prop(ob, "use_dupli_frames_speed", text="Speed")
+            layout.prop(ob, "use_dupli_frames_speed", text=_("Speed"))
 
         elif ob.dupli_type == 'VERTS':
-            layout.prop(ob, "use_dupli_vertices_rotation", text="Rotation")
+            layout.prop(ob, "use_dupli_vertices_rotation", text=_("Rotation"))
 
         elif ob.dupli_type == 'FACES':
 
             row = layout.row()
-            row.prop(ob, "use_dupli_faces_scale", text="Scale")
-            row.prop(ob, "dupli_faces_scale", text="Inherit Scale")
+            row.prop(ob, "use_dupli_faces_scale", text=_("Scale"))
+            row.prop(ob, "dupli_faces_scale", text=_("Inherit Scale"))
 
         elif ob.dupli_type == 'GROUP':
-            layout.prop(ob, "dupli_group", text="Group")
+            layout.prop(ob, "dupli_group", text=_("Group"))
 
 
 # XXX: the following options are all quite buggy, ancient hacks that should be dropped
@@ -271,21 +271,21 @@ class OBJECT_PT_animation(ObjectButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Time Offset:")
-        col.prop(ob, "use_time_offset_edit", text="Edit")
+        col.label(text=_("Time Offset:"))
+        col.prop(ob, "use_time_offset_edit", text=_("Edit"))
         row = col.row()
-        row.prop(ob, "use_time_offset_parent", text="Parent")
+        row.prop(ob, "use_time_offset_parent", text=_("Parent"))
         row.active = (ob.parent is not None)
         row = col.row()
         row.prop(ob, "use_slow_parent")
         row.active = (ob.parent is not None)
-        col.prop(ob, "time_offset", text="Offset")
+        col.prop(ob, "time_offset", text=_("Offset"))
 
         # XXX: these are still used for a few curve-related tracking features
         col = split.column()
-        col.label(text="Tracking Axes:")
-        col.prop(ob, "track_axis", text="Axis")
-        col.prop(ob, "up_axis", text="Up Axis")
+        col.label(text=_("Tracking Axes:"))
+        col.prop(ob, "track_axis", text=_("Axis"))
+        col.prop(ob, "up_axis", text=_("Up Axis"))
 
 
 from bl_ui.properties_animviz import (
@@ -312,8 +312,8 @@ class OBJECT_PT_motion_paths(MotionPathButtonsPanel, Panel):
         layout.separator()
 
         row = layout.row()
-        row.operator("object.paths_calculate", text="Calculate Paths")
-        row.operator("object.paths_clear", text="Clear Paths")
+        row.operator("object.paths_calculate", text=_("Calculate Paths"))
+        row.operator("object.paths_clear", text=_("Clear Paths"))
 
 
 class OBJECT_PT_onion_skinning(OnionSkinButtonsPanel):  # , Panel): # inherit from panel when ready
diff --git a/release/scripts/startup/bl_ui/properties_object_constraint.py b/release/scripts/startup/bl_ui/properties_object_constraint.py
index 05fac2026a0..e7385d3926b 100644
--- a/release/scripts/startup/bl_ui/properties_object_constraint.py
+++ b/release/scripts/startup/bl_ui/properties_object_constraint.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 class ConstraintButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -43,7 +43,7 @@ class ConstraintButtonsPanel():
 
             split = layout.split(percentage=0.2)
 
-            split.label(text="Space:")
+            split.label(text=_("Space:"))
             row = split.row()
 
             if target:
@@ -60,21 +60,21 @@ class ConstraintButtonsPanel():
 
         if con.target and subtargets:
             if con.target.type == 'ARMATURE':
-                layout.prop_search(con, "subtarget", con.target.data, "bones", text="Bone")
+                layout.prop_search(con, "subtarget", con.target.data, "bones", text=_("Bone"))
 
                 if hasattr(con, "head_tail"):
                     row = layout.row()
-                    row.label(text="Head/Tail:")
+                    row.label(text=_("Head/Tail:"))
                     row.prop(con, "head_tail", text="")
             elif con.target.type in {'MESH', 'LATTICE'}:
-                layout.prop_search(con, "subtarget", con.target, "vertex_groups", text="Vertex Group")
+                layout.prop_search(con, "subtarget", con.target, "vertex_groups", text=_("Vertex Group"))
 
     def ik_template(self, layout, con):
         # only used for iTaSC
         layout.prop(con, "pole_target")
 
         if con.pole_target and con.pole_target.type == 'ARMATURE':
-            layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text="Bone")
+            layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text=_("Bone"))
 
         if con.pole_target:
             row = layout.row()
@@ -96,19 +96,19 @@ class ConstraintButtonsPanel():
         split = layout.split()
 
         col = split.column()
-        col.label(text="Location:")
+        col.label(text=_("Location:"))
         col.prop(con, "use_location_x", text="X")
         col.prop(con, "use_location_y", text="Y")
         col.prop(con, "use_location_z", text="Z")
 
         col = split.column()
-        col.label(text="Rotation:")
+        col.label(text=_("Rotation:"))
         col.prop(con, "use_rotation_x", text="X")
         col.prop(con, "use_rotation_y", text="Y")
         col.prop(con, "use_rotation_z", text="Z")
 
         col = split.column()
-        col.label(text="Scale:")
+        col.label(text=_("Scale:"))
         col.prop(con, "use_scale_x", text="X")
         col.prop(con, "use_scale_y", text="Y")
         col.prop(con, "use_scale_z", text="Z")
@@ -121,11 +121,11 @@ class ConstraintButtonsPanel():
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text="To:")
+        row.label(text=_("To:"))
         row.prop(con, "track_axis", expand=True)
 
         row = layout.row()
-        row.prop(con, "up_axis", text="Up")
+        row.prop(con, "up_axis", text=_("Up"))
         row.prop(con, "use_target_z")
 
         self.space_template(layout, con)
@@ -140,7 +140,7 @@ class ConstraintButtonsPanel():
             layout.prop(con, "pole_target")
 
             if con.pole_target and con.pole_target.type == 'ARMATURE':
-                layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text="Bone")
+                layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text=_("Bone"))
 
             if con.pole_target:
                 row = layout.row()
@@ -152,11 +152,11 @@ class ConstraintButtonsPanel():
             col.prop(con, "iterations")
             col.prop(con, "chain_count")
 
-            col.label(text="Weight:")
-            col.prop(con, "weight", text="Position", slider=True)
+            col.label(text=_("Weight:"))
+            col.prop(con, "weight", text=_("Position"), slider=True)
             sub = col.column()
             sub.active = con.use_rotation
-            sub.prop(con, "orient_weight", text="Rotation", slider=True)
+            sub.prop(con, "orient_weight", text=_("Rotation"), slider=True)
 
             col = split.column()
             col.prop(con, "use_tail")
@@ -170,16 +170,16 @@ class ConstraintButtonsPanel():
         self.ik_template(layout, con)
 
         row = layout.row()
-        row.label(text="Axis Ref:")
+        row.label(text=_("Axis Ref:"))
         row.prop(con, "reference_axis", expand=True)
         split = layout.split(percentage=0.33)
         split.row().prop(con, "use_location")
         row = split.row()
-        row.prop(con, "weight", text="Weight", slider=True)
+        row.prop(con, "weight", text=_("Weight"), slider=True)
         row.active = con.use_location
         split = layout.split(percentage=0.33)
         row = split.row()
-        row.label(text="Lock:")
+        row.label(text=_("Lock:"))
         row = split.row()
         row.prop(con, "lock_location_x", text="X")
         row.prop(con, "lock_location_y", text="Y")
@@ -189,11 +189,11 @@ class ConstraintButtonsPanel():
         split = layout.split(percentage=0.33)
         split.row().prop(con, "use_rotation")
         row = split.row()
-        row.prop(con, "orient_weight", text="Weight", slider=True)
+        row.prop(con, "orient_weight", text=_("Weight"), slider=True)
         row.active = con.use_rotation
         split = layout.split(percentage=0.33)
         row = split.row()
-        row.label(text="Lock:")
+        row.label(text=_("Lock:"))
         row = split.row()
         row.prop(con, "lock_rotation_x", text="X")
         row.prop(con, "lock_rotation_y", text="Y")
@@ -207,8 +207,8 @@ class ConstraintButtonsPanel():
         layout.prop(con, "limit_mode")
 
         row = layout.row()
-        row.prop(con, "weight", text="Weight", slider=True)
-        row.prop(con, "distance", text="Distance", slider=True)
+        row.prop(con, "weight", text=_("Weight"), slider=True)
+        row.prop(con, "distance", text=_("Distance"), slider=True)
 
     def FOLLOW_PATH(self, context, layout, con):
         self.target_template(layout, con)
@@ -222,16 +222,16 @@ class ConstraintButtonsPanel():
         col = split.column()
         col.prop(con, "use_fixed_location")
         if con.use_fixed_location:
-            col.prop(con, "offset_factor", text="Offset")
+            col.prop(con, "offset_factor", text=_("Offset"))
         else:
             col.prop(con, "offset")
 
         row = layout.row()
-        row.label(text="Forward:")
+        row.label(text=_("Forward:"))
         row.prop(con, "forward_axis", expand=True)
 
         row = layout.row()
-        row.prop(con, "up_axis", text="Up")
+        row.prop(con, "up_axis", text=_("Up"))
         row.label()
 
     def LIMIT_ROTATION(self, context, layout, con):
@@ -241,27 +241,27 @@ class ConstraintButtonsPanel():
         col.prop(con, "use_limit_x")
         sub = col.column()
         sub.active = con.use_limit_x
-        sub.prop(con, "min_x", text="Min")
-        sub.prop(con, "max_x", text="Max")
+        sub.prop(con, "min_x", text=_("Min"))
+        sub.prop(con, "max_x", text=_("Max"))
 
         col = split.column(align=True)
         col.prop(con, "use_limit_y")
         sub = col.column()
         sub.active = con.use_limit_y
-        sub.prop(con, "min_y", text="Min")
-        sub.prop(con, "max_y", text="Max")
+        sub.prop(con, "min_y", text=_("Min"))
+        sub.prop(con, "max_y", text=_("Max"))
 
         col = split.column(align=True)
         col.prop(con, "use_limit_z")
         sub = col.column()
         sub.active = con.use_limit_z
-        sub.prop(con, "min_z", text="Min")
-        sub.prop(con, "max_z", text="Max")
+        sub.prop(con, "min_z", text=_("Min"))
+        sub.prop(con, "max_z", text=_("Max"))
 
         layout.prop(con, "use_transform_limit")
 
         row = layout.row()
-        row.label(text="Convert:")
+        row.label(text=_("Convert:"))
         row.prop(con, "owner_space", text="")
 
     def LIMIT_LOCATION(self, context, layout, con):
@@ -302,7 +302,7 @@ class ConstraintButtonsPanel():
         row.label()
 
         row = layout.row()
-        row.label(text="Convert:")
+        row.label(text=_("Convert:"))
         row.prop(con, "owner_space", text="")
 
     def LIMIT_SCALE(self, context, layout, con):
@@ -343,7 +343,7 @@ class ConstraintButtonsPanel():
         row.label()
 
         row = layout.row()
-        row.label(text="Convert:")
+        row.label(text=_("Convert:"))
         row.prop(con, "owner_space", text="")
 
     def COPY_ROTATION(self, context, layout, con):
@@ -355,19 +355,19 @@ class ConstraintButtonsPanel():
         col.prop(con, "use_x", text="X")
         sub = col.column()
         sub.active = con.use_x
-        sub.prop(con, "invert_x", text="Invert")
+        sub.prop(con, "invert_x", text=_("Invert"))
 
         col = split.column()
         col.prop(con, "use_y", text="Y")
         sub = col.column()
         sub.active = con.use_y
-        sub.prop(con, "invert_y", text="Invert")
+        sub.prop(con, "invert_y", text=_("Invert"))
 
         col = split.column()
         col.prop(con, "use_z", text="Z")
         sub = col.column()
         sub.active = con.use_z
-        sub.prop(con, "invert_z", text="Invert")
+        sub.prop(con, "invert_z", text=_("Invert"))
 
         layout.prop(con, "use_offset")
 
@@ -382,19 +382,19 @@ class ConstraintButtonsPanel():
         col.prop(con, "use_x", text="X")
         sub = col.column()
         sub.active = con.use_x
-        sub.prop(con, "invert_x", text="Invert")
+        sub.prop(con, "invert_x", text=_("Invert"))
 
         col = split.column()
         col.prop(con, "use_y", text="Y")
         sub = col.column()
         sub.active = con.use_y
-        sub.prop(con, "invert_y", text="Invert")
+        sub.prop(con, "invert_y", text=_("Invert"))
 
         col = split.column()
         col.prop(con, "use_z", text="Z")
         sub = col.column()
         sub.active = con.use_z
-        sub.prop(con, "invert_z", text="Invert")
+        sub.prop(con, "invert_z", text=_("Invert"))
 
         layout.prop(con, "use_offset")
 
@@ -415,7 +415,7 @@ class ConstraintButtonsPanel():
     def MAINTAIN_VOLUME(self, context, layout, con):
 
         row = layout.row()
-        row.label(text="Free:")
+        row.label(text=_("Free:"))
         row.prop(con, "free_axis", expand=True)
 
         layout.prop(con, "volume")
@@ -439,28 +439,28 @@ class ConstraintButtonsPanel():
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text="Action Length:")
-        col.prop(con, "frame_start", text="Start")
-        col.prop(con, "frame_end", text="End")
+        col.label(text=_("Action Length:"))
+        col.prop(con, "frame_start", text=_("Start"))
+        col.prop(con, "frame_end", text=_("End"))
 
         col = split.column(align=True)
-        col.label(text="Target Range:")
-        col.prop(con, "min", text="Min")
-        col.prop(con, "max", text="Max")
+        col.label(text=_("Target Range:"))
+        col.prop(con, "min", text=_("Min"))
+        col.prop(con, "max", text=_("Max"))
 
         row = layout.row()
-        row.label(text="Convert:")
+        row.label(text=_("Convert:"))
         row.prop(con, "target_space", text="")
 
     def LOCKED_TRACK(self, context, layout, con):
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text="To:")
+        row.label(text=_("To:"))
         row.prop(con, "track_axis", expand=True)
 
         row = layout.row()
-        row.label(text="Lock:")
+        row.label(text=_("Lock:"))
         row.prop(con, "lock_axis", expand=True)
 
     def LIMIT_DISTANCE(self, context, layout, con):
@@ -471,7 +471,7 @@ class ConstraintButtonsPanel():
         col.operator("constraint.limitdistance_reset")
 
         row = layout.row()
-        row.label(text="Clamp Region:")
+        row.label(text=_("Clamp Region:"))
         row.prop(con, "limit_mode", text="")
 
         row = layout.row()
@@ -482,16 +482,16 @@ class ConstraintButtonsPanel():
         self.target_template(layout, con)
 
         row = layout.row()
-        row.prop(con, "rest_length", text="Rest Length")
-        row.operator("constraint.stretchto_reset", text="Reset")
+        row.prop(con, "rest_length", text=_("Rest Length"))
+        row.operator("constraint.stretchto_reset", text=_("Reset"))
 
-        layout.prop(con, "bulge", text="Volume Variation")
+        layout.prop(con, "bulge", text=_("Volume Variation"))
 
         row = layout.row()
-        row.label(text="Volume:")
+        row.label(text=_("Volume:"))
         row.prop(con, "volume", expand=True)
 
-        row.label(text="Plane:")
+        row.label(text=_("Plane:"))
         row.prop(con, "keep_axis", expand=True)
 
     def FLOOR(self, context, layout, con):
@@ -504,7 +504,7 @@ class ConstraintButtonsPanel():
         layout.prop(con, "offset")
 
         row = layout.row()
-        row.label(text="Min/Max:")
+        row.label(text=_("Min/Max:"))
         row.prop(con, "floor_location", expand=True)
 
         self.space_template(layout, con)
@@ -516,113 +516,113 @@ class ConstraintButtonsPanel():
         layout.prop(con, "child")
 
         row = layout.row()
-        row.prop(con, "use_linked_collision", text="Linked Collision")
-        row.prop(con, "show_pivot", text="Display Pivot")
+        row.prop(con, "use_linked_collision", text=_("Linked Collision"))
+        row.prop(con, "show_pivot", text=_("Display Pivot"))
 
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text="Pivot:")
+        col.label(text=_("Pivot:"))
         col.prop(con, "pivot_x", text="X")
         col.prop(con, "pivot_y", text="Y")
         col.prop(con, "pivot_z", text="Z")
 
         col = split.column(align=True)
-        col.label(text="Axis:")
+        col.label(text=_("Axis:"))
         col.prop(con, "axis_x", text="X")
         col.prop(con, "axis_y", text="Y")
         col.prop(con, "axis_z", text="Z")
 
         if con.pivot_type == 'CONE_TWIST':
-            layout.label(text="Limits:")
+            layout.label(text=_("Limits:"))
             split = layout.split()
 
             col = split.column()
-            col.prop(con, "use_angular_limit_x", text="Angle X")
+            col.prop(con, "use_angular_limit_x", text=_("Angle X"))
             sub = col.column()
             sub.active = con.use_angular_limit_x
             sub.prop(con, "limit_angle_max_x", text="")
 
             col = split.column()
-            col.prop(con, "use_angular_limit_y", text="Angle Y")
+            col.prop(con, "use_angular_limit_y", text=_("Angle Y"))
             sub = col.column()
             sub.active = con.use_angular_limit_y
             sub.prop(con, "limit_angle_max_y", text="")
 
             col = split.column()
-            col.prop(con, "use_angular_limit_z", text="Angle Z")
+            col.prop(con, "use_angular_limit_z", text=_("Angle Z"))
             sub = col.column()
             sub.active = con.use_angular_limit_z
             sub.prop(con, "limit_angle_max_z", text="")
 
         elif con.pivot_type == 'GENERIC_6_DOF':
-            layout.label(text="Limits:")
+            layout.label(text=_("Limits:"))
             split = layout.split()
 
             col = split.column(align=True)
             col.prop(con, "use_limit_x", text="X")
             sub = col.column()
             sub.active = con.use_limit_x
-            sub.prop(con, "limit_min_x", text="Min")
-            sub.prop(con, "limit_max_x", text="Max")
+            sub.prop(con, "limit_min_x", text=_("Min"))
+            sub.prop(con, "limit_max_x", text=_("Max"))
 
             col = split.column(align=True)
             col.prop(con, "use_limit_y", text="Y")
             sub = col.column()
             sub.active = con.use_limit_y
-            sub.prop(con, "limit_min_y", text="Min")
-            sub.prop(con, "limit_max_y", text="Max")
+            sub.prop(con, "limit_min_y", text=_("Min"))
+            sub.prop(con, "limit_max_y", text=_("Max"))
 
             col = split.column(align=True)
             col.prop(con, "use_limit_z", text="Z")
             sub = col.column()
             sub.active = con.use_limit_z
-            sub.prop(con, "limit_min_z", text="Min")
-            sub.prop(con, "limit_max_z", text="Max")
+            sub.prop(con, "limit_min_z", text=_("Min"))
+            sub.prop(con, "limit_max_z", text=_("Max"))
 
             split = layout.split()
 
             col = split.column(align=True)
-            col.prop(con, "use_angular_limit_x", text="Angle X")
+            col.prop(con, "use_angular_limit_x", text=_("Angle X"))
             sub = col.column()
             sub.active = con.use_angular_limit_x
-            sub.prop(con, "limit_angle_min_x", text="Min")
-            sub.prop(con, "limit_angle_max_x", text="Max")
+            sub.prop(con, "limit_angle_min_x", text=_("Min"))
+            sub.prop(con, "limit_angle_max_x", text=_("Max"))
 
             col = split.column(align=True)
-            col.prop(con, "use_angular_limit_y", text="Angle Y")
+            col.prop(con, "use_angular_limit_y", text=_("Angle Y"))
             sub = col.column()
             sub.active = con.use_angular_limit_y
-            sub.prop(con, "limit_angle_min_y", text="Min")
-            sub.prop(con, "limit_angle_max_y", text="Max")
+            sub.prop(con, "limit_angle_min_y", text=_("Min"))
+            sub.prop(con, "limit_angle_max_y", text=_("Max"))
 
             col = split.column(align=True)
-            col.prop(con, "use_angular_limit_z", text="Angle Z")
+            col.prop(con, "use_angular_limit_z", text=_("Angle Z"))
             sub = col.column()
             sub.active = con.use_angular_limit_z
-            sub.prop(con, "limit_angle_min_z", text="Min")
-            sub.prop(con, "limit_angle_max_z", text="Max")
+            sub.prop(con, "limit_angle_min_z", text=_("Min"))
+            sub.prop(con, "limit_angle_max_z", text=_("Max"))
 
         elif con.pivot_type == 'HINGE':
-            layout.label(text="Limits:")
+            layout.label(text=_("Limits:"))
             split = layout.split()
 
             row = split.row(align=True)
             col = row.column()
-            col.prop(con, "use_angular_limit_x", text="Angle X")
+            col.prop(con, "use_angular_limit_x", text=_("Angle X"))
 
             col = row.column()
             col.active = con.use_angular_limit_x
-            col.prop(con, "limit_angle_min_x", text="Min")
+            col.prop(con, "limit_angle_min_x", text=_("Min"))
             col = row.column()
             col.active = con.use_angular_limit_x
-            col.prop(con, "limit_angle_max_x", text="Max")
+            col.prop(con, "limit_angle_max_x", text=_("Max"))
 
     def CLAMP_TO(self, context, layout, con):
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text="Main Axis:")
+        row.label(text=_("Main Axis:"))
         row.prop(con, "main_axis", expand=True)
 
         layout.prop(con, "use_cyclic")
@@ -630,32 +630,32 @@ class ConstraintButtonsPanel():
     def TRANSFORM(self, context, layout, con):
         self.target_template(layout, con)
 
-        layout.prop(con, "use_motion_extrapolate", text="Extrapolate")
+        layout.prop(con, "use_motion_extrapolate", text=_("Extrapolate"))
 
         col = layout.column()
-        col.row().label(text="Source:")
+        col.row().label(text=_("Source:"))
         col.row().prop(con, "map_from", expand=True)
 
         split = layout.split()
 
         sub = split.column(align=True)
         sub.label(text="X:")
-        sub.prop(con, "from_min_x", text="Min")
-        sub.prop(con, "from_max_x", text="Max")
+        sub.prop(con, "from_min_x", text=_("Min"))
+        sub.prop(con, "from_max_x", text=_("Max"))
 
         sub = split.column(align=True)
         sub.label(text="Y:")
-        sub.prop(con, "from_min_y", text="Min")
-        sub.prop(con, "from_max_y", text="Max")
+        sub.prop(con, "from_min_y", text=_("Min"))
+        sub.prop(con, "from_max_y", text=_("Max"))
 
         sub = split.column(align=True)
         sub.label(text="Z:")
-        sub.prop(con, "from_min_z", text="Min")
-        sub.prop(con, "from_max_z", text="Max")
+        sub.prop(con, "from_min_z", text=_("Min"))
+        sub.prop(con, "from_max_z", text=_("Max"))
 
         col = layout.column()
         row = col.row()
-        row.label(text="Source to Destination Mapping:")
+        row.label(text=_("Source to Destination Mapping:"))
 
         # note: chr(187) is the ASCII arrow ( >> ). Blender Text Editor can't
         # open it. Thus we are using the hardcoded value instead.
@@ -674,7 +674,7 @@ class ConstraintButtonsPanel():
         split = layout.split()
 
         col = split.column()
-        col.label(text="Destination:")
+        col.label(text=_("Destination:"))
         col.row().prop(con, "map_to", expand=True)
 
         split = layout.split()
@@ -683,22 +683,22 @@ class ConstraintButtonsPanel():
         col.label(text="X:")
 
         sub = col.column(align=True)
-        sub.prop(con, "to_min_x", text="Min")
-        sub.prop(con, "to_max_x", text="Max")
+        sub.prop(con, "to_min_x", text=_("Min"))
+        sub.prop(con, "to_max_x", text=_("Max"))
 
         col = split.column()
         col.label(text="Y:")
 
         sub = col.column(align=True)
-        sub.prop(con, "to_min_y", text="Min")
-        sub.prop(con, "to_max_y", text="Max")
+        sub.prop(con, "to_min_y", text=_("Min"))
+        sub.prop(con, "to_max_y", text=_("Max"))
 
         col = split.column()
         col.label(text="Z:")
 
         sub = col.column(align=True)
-        sub.prop(con, "to_min_z", text="Min")
-        sub.prop(con, "to_max_z", text="Max")
+        sub.prop(con, "to_min_z", text=_("Min"))
+        sub.prop(con, "to_max_z", text=_("Max"))
 
         self.space_template(layout, con)
 
@@ -718,20 +718,20 @@ class ConstraintButtonsPanel():
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text="To:")
+        row.label(text=_("To:"))
         row.prop(con, "track_axis", expand=True)
 
     def SPLINE_IK(self, context, layout, con):
         self.target_template(layout, con)
 
         col = layout.column()
-        col.label(text="Spline Fitting:")
+        col.label(text=_("Spline Fitting:"))
         col.prop(con, "chain_count")
         col.prop(con, "use_even_divisions")
         col.prop(con, "use_chain_offset")
 
         col = layout.column()
-        col.label(text="Chain Scaling:")
+        col.label(text=_("Chain Scaling:"))
         col.prop(con, "use_y_stretch")
         col.prop(con, "xz_scale_mode")
         col.prop(con, "use_curve_radius")
@@ -741,20 +741,20 @@ class ConstraintButtonsPanel():
 
         if con.target:
             col = layout.column()
-            col.prop(con, "offset", text="Pivot Offset")
+            col.prop(con, "offset", text=_("Pivot Offset"))
         else:
             col = layout.column()
             col.prop(con, "use_relative_location")
             if con.use_relative_location:
-                col.prop(con, "offset", text="Relative Pivot Point")
+                col.prop(con, "offset", text=_("Relative Pivot Point"))
             else:
-                col.prop(con, "offset", text="Absolute Pivot Point")
+                col.prop(con, "offset", text=_("Absolute Pivot Point"))
 
         col = layout.column()
-        col.prop(con, "rotation_range", text="Pivot When")
+        col.prop(con, "rotation_range", text=_("Pivot When"))
 
     def SCRIPT(self, context, layout, con):
-        layout.label("Blender 2.5 has no py-constraints")
+        layout.label( _("Blender 2.5 has no py-constraints") )
 
 
 class OBJECT_PT_constraints(ConstraintButtonsPanel, Panel):
@@ -773,7 +773,7 @@ class OBJECT_PT_constraints(ConstraintButtonsPanel, Panel):
         if ob.mode == 'POSE':
             box = layout.box()
             box.alert = True
-            box.label(icon='INFO', text="See Bone Constraints tab to Add Constraints to active bone")
+            box.label(icon='INFO', text=_("See Bone Constraints tab to Add Constraints to active bone"))
         else:
             layout.operator_menu_enum("object.constraint_add", "type")
 
diff --git a/release/scripts/startup/bl_ui/properties_particle.py b/release/scripts/startup/bl_ui/properties_particle.py
index d4378b0d094..6424f6dca44 100644
--- a/release/scripts/startup/bl_ui/properties_particle.py
+++ b/release/scripts/startup/bl_ui/properties_particle.py
@@ -20,6 +20,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
+from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -108,17 +109,17 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
             layout.template_ID(context.space_data, "pin_id")
 
             if part.is_fluid:
-                layout.label(text="Settings used for fluid")
+                layout.label(text=_("Settings used for fluid"))
                 return
 
-            layout.prop(part, "type", text="Type")
+            layout.prop(part, "type", text=_("Type"))
 
         elif not psys.settings:
             split = layout.split(percentage=0.32)
 
             col = split.column()
-            col.label(text="Name:")
-            col.label(text="Settings:")
+            col.label(text=_("Name:"))
+            col.label(text=_("Settings:"))
 
             col = split.column()
             col.prop(psys, "name", text="")
@@ -128,10 +129,10 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
 
             split = layout.split(percentage=0.32)
             col = split.column()
-            col.label(text="Name:")
+            col.label(text=_("Name:"))
             if part.is_fluid == False:
-                col.label(text="Settings:")
-                col.label(text="Type:")
+                col.label(text=_("Settings:"))
+                col.label(text=_("Type:"))
 
             col = split.column()
             col.prop(psys, "name", text="")
@@ -141,8 +142,8 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
                 row.template_ID(psys, "settings", new="particle.new")
 
             #row = layout.row()
-            #row.label(text="Viewport")
-            #row.label(text="Render")
+            #row.label(text=_("Viewport"))
+            #row.label(text=_("Render"))
 
             if part.is_fluid:
                 layout.label(text=str(part.count) + " fluid particles for this frame")
@@ -157,7 +158,7 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
             split = layout.split(percentage=0.65)
             if part.type == 'HAIR':
                 if psys is not None and psys.is_edited:
-                    split.operator("particle.edited_clear", text="Free Edit")
+                    split.operator("particle.edited_clear", text=_("Free Edit"))
                 else:
                     row = split.row()
                     row.enabled = particle_panel_enabled(context, psys)
@@ -174,7 +175,7 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
             elif psys is not None and part.type == 'REACTOR':
                 split.enabled = particle_panel_enabled(context, psys)
                 split.prop(psys, "reactor_target_object")
-                split.prop(psys, "reactor_target_particle_system", text="Particle System")
+                split.prop(psys, "reactor_target_particle_system", text=_("Particle System"))
 
 
 class PARTICLE_PT_emission(ParticleButtonsPanel, Panel):
@@ -221,7 +222,7 @@ class PARTICLE_PT_emission(ParticleButtonsPanel, Panel):
             col.prop(part, "lifetime")
             col.prop(part, "lifetime_random", slider=True)
 
-        layout.label(text="Emit From:")
+        layout.label(text=_("Emit From:"))
         layout.prop(part, "emit_from", expand=True)
 
         row = layout.row()
@@ -239,11 +240,11 @@ class PARTICLE_PT_emission(ParticleButtonsPanel, Panel):
 
             row = layout.row()
             if part.distribution == 'JIT':
-                row.prop(part, "userjit", text="Particles/Face")
-                row.prop(part, "jitter_factor", text="Jittering Amount", slider=True)
+                row.prop(part, "userjit", text=_("Particles/Face"))
+                row.prop(part, "jitter_factor", text=_("Jittering Amount"), slider=True)
             elif part.distribution == 'GRID':
                 row.prop(part, "grid_resolution")
-                row.prop(part, "grid_random", text="Random", slider=True)
+                row.prop(part, "grid_random", text=_("Random"), slider=True)
 
 
 class PARTICLE_PT_hair_dynamics(ParticleButtonsPanel, Panel):
@@ -284,22 +285,22 @@ class PARTICLE_PT_hair_dynamics(ParticleButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Material:")
+        col.label(text=_("Material:"))
         sub = col.column(align=True)
-        sub.prop(cloth, "pin_stiffness", text="Stiffness")
+        sub.prop(cloth, "pin_stiffness", text=_("Stiffness"))
         sub.prop(cloth, "mass")
-        sub.prop(cloth, "bending_stiffness", text="Bending")
+        sub.prop(cloth, "bending_stiffness", text=_("Bending"))
         sub.prop(cloth, "internal_friction", slider=True)
         sub.prop(cloth, "collider_friction", slider=True)
 
         col = split.column()
-        col.label(text="Damping:")
+        col.label(text=_("Damping:"))
         sub = col.column(align=True)
-        sub.prop(cloth, "spring_damping", text="Spring")
-        sub.prop(cloth, "air_damping", text="Air")
+        sub.prop(cloth, "spring_damping", text=_("Spring"))
+        sub.prop(cloth, "air_damping", text=_("Air"))
 
-        col.label(text="Quality:")
-        col.prop(cloth, "quality", text="Steps", slider=True)
+        col.label(text=_("Quality:"))
+        col.prop(cloth, "quality", text=_("Steps"), slider=True)
 
 
 class PARTICLE_PT_cache(ParticleButtonsPanel, Panel):
@@ -355,17 +356,17 @@ class PARTICLE_PT_velocity(ParticleButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Emitter Geometry:")
+        col.label(text=_("Emitter Geometry:"))
         col.prop(part, "normal_factor")
         sub = col.column(align=True)
         sub.prop(part, "tangent_factor")
         sub.prop(part, "tangent_phase", slider=True)
 
         col = split.column()
-        col.label(text="Emitter Object:")
+        col.label(text=_("Emitter Object:"))
         col.prop(part, "object_align_factor", text="")
 
-        layout.label(text="Other:")
+        layout.label(text=_("Other:"))
         row = layout.row()
         if part.emit_from == 'PARTICLE':
             row.prop(part, "particle_factor")
@@ -406,21 +407,21 @@ class PARTICLE_PT_rotation(ParticleButtonsPanel, Panel):
         layout.enabled = particle_panel_enabled(context, psys)
 
         row = layout.row()
-        row.label(text="Initial Rotation:")
+        row.label(text=_("Initial Rotation:"))
         row.prop(part, "use_dynamic_rotation")
 
         split = layout.split()
 
         col = split.column(align=True)
         col.prop(part, "rotation_mode", text="")
-        col.prop(part, "rotation_factor_random", slider=True, text="Random")
+        col.prop(part, "rotation_factor_random", slider=True, text=_("Random"))
 
         col = split.column(align=True)
         col.prop(part, "phase_factor", slider=True)
-        col.prop(part, "phase_factor_random", text="Random", slider=True)
+        col.prop(part, "phase_factor_random", text=_("Random"), slider=True)
 
         col = layout.column()
-        col.label(text="Angular Velocity:")
+        col.label(text=_("Angular Velocity:"))
         col.row().prop(part, "angular_velocity_mode", expand=True)
 
         if part.angular_velocity_mode != 'NONE':
@@ -461,19 +462,19 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
         if part.physics_type != 'NO':
             col = row.column(align=True)
             col.prop(part, "mass")
-            col.prop(part, "use_multiply_size_mass", text="Multiply mass with size")
+            col.prop(part, "use_multiply_size_mass", text=_("Multiply mass with size"))
 
         if part.physics_type in {'NEWTON', 'FLUID'}:
             split = layout.split()
 
             col = split.column()
-            col.label(text="Forces:")
+            col.label(text=_("Forces:"))
             col.prop(part, "brownian_factor")
             col.prop(part, "drag_factor", slider=True)
             col.prop(part, "damping", slider=True)
 
             col = split.column()
-            col.label(text="Integration:")
+            col.label(text=_("Integration:"))
             col.prop(part, "integrator", text="")
             col.prop(part, "timestep")
             col.prop(part, "subframes")
@@ -488,13 +489,13 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Fluid properties:")
-                col.prop(fluid, "stiffness", text="Stiffness")
-                col.prop(fluid, "linear_viscosity", text="Viscosity")
-                col.prop(fluid, "buoyancy", text="Buoancy", slider=True)
+                col.label(text=_("Fluid properties:"))
+                col.prop(fluid, "stiffness", text=_("Stiffness"))
+                col.prop(fluid, "linear_viscosity", text=_("Viscosity"))
+                col.prop(fluid, "buoyancy", text=_("Buoancy"), slider=True)
 
                 col = split.column()
-                col.label(text="Advanced:")
+                col.label(text=_("Advanced:"))
 
                 sub = col.row()
                 sub.prop(fluid, "repulsion", slider=fluid.factor_repulsion)
@@ -515,8 +516,8 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Springs:")
-                col.prop(fluid, "spring_force", text="Force")
+                col.label(text=_("Springs:"))
+                col.prop(fluid, "spring_force", text=_("Force"))
                 col.prop(fluid, "use_viscoelastic_springs")
                 sub = col.column(align=True)
                 sub.active = fluid.use_viscoelastic_springs
@@ -524,7 +525,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 sub.prop(fluid, "plasticity", slider=True)
 
                 col = split.column()
-                col.label(text="Advanced:")
+                col.label(text=_("Advanced:"))
                 sub = col.row()
                 sub.prop(fluid, "rest_length", slider=fluid.factor_rest_length)
                 sub.prop(fluid, "factor_rest_length", text="")
@@ -532,7 +533,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 sub = col.column()
                 sub.active = fluid.use_viscoelastic_springs
                 sub.prop(fluid, "use_initial_rest_length")
-                sub.prop(fluid, "spring_frames", text="Frames")
+                sub.prop(fluid, "spring_frames", text=_("Frames"))
 
         elif part.physics_type == 'KEYED':
             split = layout.split()
@@ -541,11 +542,11 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             row = layout.row()
             col = row.column()
             col.active = not psys.use_keyed_timing
-            col.prop(part, "keyed_loops", text="Loops")
+            col.prop(part, "keyed_loops", text=_("Loops"))
             if psys:
-                row.prop(psys, "use_keyed_timing", text="Use Timing")
+                row.prop(psys, "use_keyed_timing", text=_("Use Timing"))
 
-            layout.label(text="Keys:")
+            layout.label(text=_("Keys:"))
         elif part.physics_type == 'BOIDS':
             boids = part.boids
 
@@ -581,7 +582,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             row = layout.row()
 
             col = row.column(align=True)
-            col.label(text="Battle:")
+            col.label(text=_("Battle:"))
             col.prop(boids, "health")
             col.prop(boids, "strength")
             col.prop(boids, "aggression")
@@ -589,16 +590,16 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             col.prop(boids, "range")
 
             col = row.column()
-            col.label(text="Misc:")
+            col.label(text=_("Misc:"))
             col.prop(boids, "bank", slider=True)
             col.prop(boids, "pitch", slider=True)
             col.prop(boids, "height", slider=True)
 
         if psys and part.physics_type in {'KEYED', 'BOIDS', 'FLUID'}:
             if part.physics_type == 'BOIDS':
-                layout.label(text="Relations:")
+                layout.label(text=_("Relations:"))
             elif part.physics_type == 'FLUID':
-                layout.label(text="Fluid interaction:")
+                layout.label(text=_("Fluid interaction:"))
 
             row = layout.row()
             row.template_list(psys, "targets", psys, "active_particle_target_index")
@@ -621,7 +622,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     #doesn't work yet
                     #col.alert = key.valid
                     col.prop(key, "object", text="")
-                    col.prop(key, "system", text="System")
+                    col.prop(key, "system", text=_("System"))
                     col = row.column()
                     col.active = psys.use_keyed_timing
                     col.prop(key, "time")
@@ -631,7 +632,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     #doesn't work yet
                     #sub.alert = key.valid
                     sub.prop(key, "object", text="")
-                    sub.prop(key, "system", text="System")
+                    sub.prop(key, "system", text=_("System"))
 
                     layout.prop(key, "alliance", expand=True)
                 elif part.physics_type == 'FLUID':
@@ -639,7 +640,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     #doesn't work yet
                     #sub.alert = key.valid
                     sub.prop(key, "object", text="")
-                    sub.prop(key, "system", text="System")
+                    sub.prop(key, "system", text=_("System"))
 
 
 class PARTICLE_PT_boidbrain(ParticleButtonsPanel, Panel):
@@ -678,7 +679,7 @@ class PARTICLE_PT_boidbrain(ParticleButtonsPanel, Panel):
 
         state = boids.active_boid_state
 
-        #layout.prop(state, "name", text="State name")
+        #layout.prop(state, "name", text=_("State name"))
 
         row = layout.row()
         row.prop(state, "ruleset_type")
@@ -721,7 +722,7 @@ class PARTICLE_PT_boidbrain(ParticleButtonsPanel, Panel):
                 row.prop(rule, "use_predict")
                 row.prop(rule, "fear_factor")
             elif rule.type == 'FOLLOW_PATH':
-                row.label(text="Not yet functional")
+                row.label(text=_("Not yet functional"))
             elif rule.type == 'AVOID_COLLISION':
                 row.prop(rule, "use_avoid")
                 row.prop(rule, "use_avoid_collision")
@@ -800,14 +801,14 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
             sub.active = (part.use_render_adaptive is True and part.use_strand_primitive is False)
             sub.prop(part, "adaptive_pixel")
             col.prop(part, "use_hair_bspline")
-            col.prop(part, "render_step", text="Steps")
+            col.prop(part, "render_step", text=_("Steps"))
 
             col = split.column()
-            col.label(text="Timing:")
+            col.label(text=_("Timing:"))
             col.prop(part, "use_absolute_path_time")
-            col.prop(part, "path_start", text="Start", slider=not part.use_absolute_path_time)
-            col.prop(part, "path_end", text="End", slider=not part.use_absolute_path_time)
-            col.prop(part, "length_random", text="Random", slider=True)
+            col.prop(part, "path_start", text=_("Start"), slider=not part.use_absolute_path_time)
+            col.prop(part, "path_end", text=_("End"), slider=not part.use_absolute_path_time)
+            col.prop(part, "length_random", text=_("Random"), slider=True)
 
             row = layout.row()
             col = row.column()
@@ -864,30 +865,30 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
         elif part.render_type == 'BILLBOARD':
             ob = context.object
 
-            col.label(text="Align:")
+            col.label(text=_("Align:"))
 
             row = layout.row()
             row.prop(part, "billboard_align", expand=True)
-            row.prop(part, "lock_billboard", text="Lock")
+            row.prop(part, "lock_billboard", text=_("Lock"))
             row = layout.row()
             row.prop(part, "billboard_object")
 
             row = layout.row()
             col = row.column(align=True)
-            col.label(text="Tilt:")
-            col.prop(part, "billboard_tilt", text="Angle", slider=True)
-            col.prop(part, "billboard_tilt_random", text="Random", slider=True)
+            col.label(text=_("Tilt:"))
+            col.prop(part, "billboard_tilt", text=_("Angle"), slider=True)
+            col.prop(part, "billboard_tilt_random", text=_("Random"), slider=True)
             col = row.column()
             col.prop(part, "billboard_offset")
 
             row = layout.row()
             col = row.column()
-            col.prop(part, "billboard_size", text="Scale")
+            col.prop(part, "billboard_size", text=_("Scale"))
             if part.billboard_align == 'VEL':
                 col = row.column(align=True)
-                col.label("Velocity Scale:")
-                col.prop(part, "billboard_velocity_head", text="Head")
-                col.prop(part, "billboard_velocity_tail", text="Tail")
+                col.label(_("Velocity Scale:"))
+                col.prop(part, "billboard_velocity_head", text=_("Head"))
+                col.prop(part, "billboard_velocity_tail", text=_("Tail"))
 
             if psys:
                 col = layout.column()
@@ -895,8 +896,8 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
                 col.prop_search(psys, "billboard_time_index_uv", ob.data, "uv_textures")
 
             split = layout.split(percentage=0.33)
-            split.label(text="Split uv's:")
-            split.prop(part, "billboard_uv_split", text="Number of splits")
+            split.label(text=_("Split uv's:"))
+            split.prop(part, "billboard_uv_split", text=_("Number of splits"))
 
             if psys:
                 col = layout.column()
@@ -904,9 +905,9 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
                 col.prop_search(psys, "billboard_split_uv", ob.data, "uv_textures")
 
             row = col.row()
-            row.label(text="Animate:")
+            row.label(text=_("Animate:"))
             row.prop(part, "billboard_animation", text="")
-            row.label(text="Offset:")
+            row.label(text=_("Offset:"))
             row.prop(part, "billboard_offset_split", text="")
 
         if part.render_type == 'HALO' or part.render_type == 'LINE' or part.render_type == 'BILLBOARD':
@@ -914,10 +915,10 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
             col = row.column()
             col.prop(part, "trail_count")
             if part.trail_count > 1:
-                col.prop(part, "use_absolute_path_time", text="Length in frames")
+                col.prop(part, "use_absolute_path_time", text=_("Length in frames"))
                 col = row.column()
-                col.prop(part, "path_end", text="Length", slider=not part.use_absolute_path_time)
-                col.prop(part, "length_random", text="Random", slider=True)
+                col.prop(part, "path_end", text=_("Length"), slider=not part.use_absolute_path_time)
+                col.prop(part, "length_random", text=_("Random"), slider=True)
             else:
                 col = row.column()
                 col.label(text="")
@@ -965,11 +966,11 @@ class PARTICLE_PT_draw(ParticleButtonsPanel, Panel):
         if part.draw_percentage != 100 and psys is not None:
             if part.type == 'HAIR':
                 if psys.use_hair_dynamics and psys.point_cache.is_baked == False:
-                    layout.row().label(text="Display percentage makes dynamics inaccurate without baking!")
+                    layout.row().label(text=_("Display percentage makes dynamics inaccurate without baking!"))
             else:
                 phystype = part.physics_type
                 if phystype != 'NO' and phystype != 'KEYED' and psys.point_cache.is_baked == False:
-                    layout.row().label(text="Display percentage makes dynamics inaccurate without baking!")
+                    layout.row().label(text=_("Display percentage makes dynamics inaccurate without baking!"))
 
         row = layout.row()
         col = row.column()
@@ -980,11 +981,11 @@ class PARTICLE_PT_draw(ParticleButtonsPanel, Panel):
             col.prop(part, "show_health")
 
         col = row.column(align=True)
-        col.label(text="Color:")
+        col.label(text=_("Color:"))
         col.prop(part, "draw_color", text="")
         sub = col.row()
         sub.active = part.draw_color in ('VELOCITY', 'ACCELERATION')
-        sub.prop(part, "color_maximum", text="Max")
+        sub.prop(part, "color_maximum", text=_("Max"))
 
         if (path):
             col.prop(part, "draw_step")
@@ -1013,24 +1014,24 @@ class PARTICLE_PT_children(ParticleButtonsPanel, Panel):
         row = layout.row()
 
         col = row.column(align=True)
-        col.prop(part, "child_nbr", text="Display")
-        col.prop(part, "rendered_child_count", text="Render")
+        col.prop(part, "child_nbr", text=_("Display"))
+        col.prop(part, "rendered_child_count", text=_("Render"))
 
         if part.child_type == 'INTERPOLATED':
             col = row.column()
             if psys:
-                col.prop(psys, "child_seed", text="Seed")
+                col.prop(psys, "child_seed", text=_("Seed"))
             col.prop(part, "virtual_parents", slider=True)
             col.prop(part, "create_long_hair_children")
         else:
             col = row.column(align=True)
-            col.prop(part, "child_size", text="Size")
-            col.prop(part, "child_size_random", text="Random")
+            col.prop(part, "child_size", text=_("Size"))
+            col.prop(part, "child_size_random", text=_("Random"))
 
         split = layout.split()
 
         col = split.column()
-        col.label(text="Effects:")
+        col.label(text=_("Effects:"))
 
         sub = col.column(align=True)
         sub.prop(part, "clump_factor", slider=True)
@@ -1042,38 +1043,38 @@ class PARTICLE_PT_children(ParticleButtonsPanel, Panel):
 
         if part.child_type == 'SIMPLE':
             sub = col.column(align=True)
-            sub.prop(part, "child_radius", text="Radius")
-            sub.prop(part, "child_roundness", text="Roundness", slider=True)
+            sub.prop(part, "child_radius", text=_("Radius"))
+            sub.prop(part, "child_roundness", text=_("Roundness"), slider=True)
             if psys:
-                sub.prop(psys, "child_seed", text="Seed")
+                sub.prop(psys, "child_seed", text=_("Seed"))
         elif part.virtual_parents > 0.0:
             sub = col.column(align=True)
-            sub.label(text="Parting not")
-            sub.label(text="available with")
-            sub.label(text="virtual parents")
+            sub.label(text=_("Parting not"))
+            sub.label(text=_("available with"))
+            sub.label(text=_("virtual parents"))
         else:
             sub = col.column(align=True)
-            sub.prop(part, "child_parting_factor", text="Parting", slider=True)
-            sub.prop(part, "child_parting_min", text="Min")
-            sub.prop(part, "child_parting_max", text="Max")
+            sub.prop(part, "child_parting_factor", text=_("Parting"), slider=True)
+            sub.prop(part, "child_parting_min", text=_("Min"))
+            sub.prop(part, "child_parting_max", text=_("Max"))
 
         col = split.column()
-        col.label(text="Roughness:")
+        col.label(text=_("Roughness:"))
 
         sub = col.column(align=True)
-        sub.prop(part, "roughness_1", text="Uniform")
-        sub.prop(part, "roughness_1_size", text="Size")
+        sub.prop(part, "roughness_1", text=_("Uniform"))
+        sub.prop(part, "roughness_1_size", text=_("Size"))
 
         sub = col.column(align=True)
         sub.prop(part, "roughness_endpoint", "Endpoint")
         sub.prop(part, "roughness_end_shape")
 
         sub = col.column(align=True)
-        sub.prop(part, "roughness_2", text="Random")
-        sub.prop(part, "roughness_2_size", text="Size")
+        sub.prop(part, "roughness_2", text=_("Random"))
+        sub.prop(part, "roughness_2_size", text=_("Size"))
         sub.prop(part, "roughness_2_threshold", slider=True)
 
-        layout.row().label(text="Kink:")
+        layout.row().label(text=_("Kink:"))
         layout.row().prop(part, "kink", expand=True)
 
         split = layout.split()
@@ -1082,7 +1083,7 @@ class PARTICLE_PT_children(ParticleButtonsPanel, Panel):
         col = split.column()
         sub = col.column(align=True)
         sub.prop(part, "kink_amplitude")
-        sub.prop(part, "kink_amplitude_clump", text="Clump", slider=True)
+        sub.prop(part, "kink_amplitude_clump", text=_("Clump"), slider=True)
         col.prop(part, "kink_flat", slider=True)
         col = split.column()
         sub = col.column(align=True)
@@ -1123,25 +1124,25 @@ class PARTICLE_PT_force_fields(ParticleButtonsPanel, Panel):
 
         row = layout.row()
         row.prop(part, "use_self_effect")
-        row.prop(part, "effector_amount", text="Amount")
+        row.prop(part, "effector_amount", text=_("Amount"))
 
         split = layout.split(percentage=0.2)
-        split.label(text="Type 1:")
+        split.label(text=_("Type 1:"))
         split.prop(part.force_field_1, "type", text="")
         basic_force_field_settings_ui(self, context, part.force_field_1)
         if part.force_field_1.type != 'NONE':
-            layout.label(text="Falloff:")
+            layout.label(text=_("Falloff:"))
         basic_force_field_falloff_ui(self, context, part.force_field_1)
 
         if part.force_field_1.type != 'NONE':
             layout.label(text="")
 
         split = layout.split(percentage=0.2)
-        split.label(text="Type 2:")
+        split.label(text=_("Type 2:"))
         split.prop(part.force_field_2, "type", text="")
         basic_force_field_settings_ui(self, context, part.force_field_2)
         if part.force_field_2.type != 'NONE':
-            layout.label(text="Falloff:")
+            layout.label(text=_("Falloff:"))
         basic_force_field_falloff_ui(self, context, part.force_field_2)
 
 
@@ -1163,56 +1164,56 @@ class PARTICLE_PT_vertexgroups(ParticleButtonsPanel, Panel):
         psys = context.particle_system
 
         row = layout.row()
-        row.label(text="Vertex Group")
-        row.label(text="Negate")
+        row.label(text=_("Vertex Group"))
+        row.label(text=_("Negate"))
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_density", ob, "vertex_groups", text="Density")
+        row.prop_search(psys, "vertex_group_density", ob, "vertex_groups", text=_("Density"))
         row.prop(psys, "invert_vertex_group_density", text="")
 
         # Commented out vertex groups don't work and are still waiting for better implementation
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_velocity", ob, "vertex_groups", text="Velocity")
+        # row.prop_search(psys, "vertex_group_velocity", ob, "vertex_groups", text=_("Velocity"))
         # row.prop(psys, "invert_vertex_group_velocity", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_length", ob, "vertex_groups", text="Length")
+        row.prop_search(psys, "vertex_group_length", ob, "vertex_groups", text=_("Length"))
         row.prop(psys, "invert_vertex_group_length", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_clump", ob, "vertex_groups", text="Clump")
+        row.prop_search(psys, "vertex_group_clump", ob, "vertex_groups", text=_("Clump"))
         row.prop(psys, "invert_vertex_group_clump", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_kink", ob, "vertex_groups", text="Kink")
+        row.prop_search(psys, "vertex_group_kink", ob, "vertex_groups", text=_("Kink"))
         row.prop(psys, "invert_vertex_group_kink", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_roughness_1", ob, "vertex_groups", text="Roughness 1")
+        row.prop_search(psys, "vertex_group_roughness_1", ob, "vertex_groups", text=_("Roughness 1"))
         row.prop(psys, "invert_vertex_group_roughness_1", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_roughness_2", ob, "vertex_groups", text="Roughness 2")
+        row.prop_search(psys, "vertex_group_roughness_2", ob, "vertex_groups", text=_("Roughness 2"))
         row.prop(psys, "invert_vertex_group_roughness_2", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_roughness_end", ob, "vertex_groups", text="Roughness End")
+        row.prop_search(psys, "vertex_group_roughness_end", ob, "vertex_groups", text=_("Roughness End"))
         row.prop(psys, "invert_vertex_group_roughness_end", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_size", ob, "vertex_groups", text="Size")
+        # row.prop_search(psys, "vertex_group_size", ob, "vertex_groups", text=_("Size"))
         # row.prop(psys, "invert_vertex_group_size", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_tangent", ob, "vertex_groups", text="Tangent")
+        # row.prop_search(psys, "vertex_group_tangent", ob, "vertex_groups", text=_("Tangent"))
         # row.prop(psys, "invert_vertex_group_tangent", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_rotation", ob, "vertex_groups", text="Rotation")
+        # row.prop_search(psys, "vertex_group_rotation", ob, "vertex_groups", text=_("Rotation"))
         # row.prop(psys, "invert_vertex_group_rotation", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_field", ob, "vertex_groups", text="Field")
+        # row.prop_search(psys, "vertex_group_field", ob, "vertex_groups", text=_("Field"))
         # row.prop(psys, "invert_vertex_group_field", text="")
 
 
diff --git a/release/scripts/startup/bl_ui/properties_physics_cloth.py b/release/scripts/startup/bl_ui/properties_physics_cloth.py
index d5427d8bae8..de74d1473c8 100644
--- a/release/scripts/startup/bl_ui/properties_physics_cloth.py
+++ b/release/scripts/startup/bl_ui/properties_physics_cloth.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Menu, Panel
-
+from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -71,50 +71,50 @@ class PHYSICS_PT_cloth(PhysicButtonsPanel, Panel):
 
             col = split.column()
 
-            col.label(text="Presets:")
+            col.label(text=_("Presets:"))
             sub = col.row(align=True)
             sub.menu("CLOTH_MT_presets", text=bpy.types.CLOTH_MT_presets.bl_label)
             sub.operator("cloth.preset_add", text="", icon="ZOOMIN")
             sub.operator("cloth.preset_add", text="", icon="ZOOMOUT").remove_active = True
 
-            col.label(text="Quality:")
-            col.prop(cloth, "quality", text="Steps", slider=True)
+            col.label(text=_("Quality:"))
+            col.prop(cloth, "quality", text=_("Steps"), slider=True)
 
-            col.label(text="Material:")
+            col.label(text=_("Material:"))
             col.prop(cloth, "mass")
-            col.prop(cloth, "structural_stiffness", text="Structural")
-            col.prop(cloth, "bending_stiffness", text="Bending")
+            col.prop(cloth, "structural_stiffness", text=_("Structural"))
+            col.prop(cloth, "bending_stiffness", text=_("Bending"))
 
             col = split.column()
 
-            col.label(text="Damping:")
-            col.prop(cloth, "spring_damping", text="Spring")
-            col.prop(cloth, "air_damping", text="Air")
+            col.label(text=_("Damping:"))
+            col.prop(cloth, "spring_damping", text=_("Spring"))
+            col.prop(cloth, "air_damping", text=_("Air"))
 
-            col.prop(cloth, "use_pin_cloth", text="Pinning")
+            col.prop(cloth, "use_pin_cloth", text=_("Pinning"))
             sub = col.column()
             sub.active = cloth.use_pin_cloth
             sub.prop_search(cloth, "vertex_group_mass", ob, "vertex_groups", text="")
-            sub.prop(cloth, "pin_stiffness", text="Stiffness")
+            sub.prop(cloth, "pin_stiffness", text=_("Stiffness"))
 
-            col.label(text="Pre roll:")
-            col.prop(cloth, "pre_roll", text="Frame")
+            col.label(text=_("Pre roll:"))
+            col.prop(cloth, "pre_roll", text=_("Frame"))
 
             # Disabled for now
             """
             if cloth.vertex_group_mass:
-                layout.label(text="Goal:")
+                layout.label(text=_("Goal:"))
 
                 col = layout.column_flow()
-                col.prop(cloth, "goal_default", text="Default")
-                col.prop(cloth, "goal_spring", text="Stiffness")
-                col.prop(cloth, "goal_friction", text="Friction")
+                col.prop(cloth, "goal_default", text=_("Default"))
+                col.prop(cloth, "goal_spring", text=_("Stiffness"))
+                col.prop(cloth, "goal_friction", text=_("Friction"))
             """
 
             key = ob.data.shape_keys
 
             if key:
-                col.label(text="Rest Shape Key:")
+                col.label(text=_("Rest Shape Key:"))
                 col.prop_search(cloth, "rest_shape_key", key, "key_blocks", text="")
 
 
@@ -156,18 +156,18 @@ class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(cloth, "collision_quality", slider=True, text="Quality")
-        col.prop(cloth, "distance_min", slider=True, text="Distance")
-        col.prop(cloth, "repel_force", slider=True, text="Repel")
-        col.prop(cloth, "distance_repel", slider=True, text="Repel Distance")
+        col.prop(cloth, "collision_quality", slider=True, text=_("Quality"))
+        col.prop(cloth, "distance_min", slider=True, text=_("Distance"))
+        col.prop(cloth, "repel_force", slider=True, text=_("Repel"))
+        col.prop(cloth, "distance_repel", slider=True, text=_("Repel Distance"))
         col.prop(cloth, "friction")
 
         col = split.column()
-        col.prop(cloth, "use_self_collision", text="Self Collision")
+        col.prop(cloth, "use_self_collision", text=_("Self Collision"))
         sub = col.column()
         sub.active = cloth.use_self_collision
-        sub.prop(cloth, "self_collision_quality", slider=True, text="Quality")
-        sub.prop(cloth, "self_distance_min", slider=True, text="Distance")
+        sub.prop(cloth, "self_collision_quality", slider=True, text=_("Quality"))
+        sub.prop(cloth, "self_distance_min", slider=True, text=_("Distance"))
 
         layout.prop(cloth, "group")
 
@@ -198,14 +198,14 @@ class PHYSICS_PT_cloth_stiffness(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Structural Stiffness:")
+        col.label(text=_("Structural Stiffness:"))
         col.prop_search(cloth, "vertex_group_structural_stiffness", ob, "vertex_groups", text="")
-        col.prop(cloth, "structural_stiffness_max", text="Max")
+        col.prop(cloth, "structural_stiffness_max", text=_("Max"))
 
         col = split.column()
-        col.label(text="Bending Stiffness:")
+        col.label(text=_("Bending Stiffness:"))
         col.prop_search(cloth, "vertex_group_bending", ob, "vertex_groups", text="")
-        col.prop(cloth, "bending_stiffness_max", text="Max")
+        col.prop(cloth, "bending_stiffness_max", text=_("Max"))
 
 
 class PHYSICS_PT_cloth_field_weights(PhysicButtonsPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_physics_common.py b/release/scripts/startup/bl_ui/properties_physics_common.py
index 204e25d9f01..20b76ec0a84 100644
--- a/release/scripts/startup/bl_ui/properties_physics_common.py
+++ b/release/scripts/startup/bl_ui/properties_physics_common.py
@@ -20,7 +20,7 @@
 
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 class PhysicButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -53,27 +53,27 @@ class PHYSICS_PT_add(PhysicButtonsPanel, Panel):
         ob = context.object
 
         layout = self.layout
-        layout.label("Enable physics for:")
+        layout.label(_("Enable physics for:"))
         split = layout.split()
         col = split.column()
 
         if(context.object.field.type == 'NONE'):
-            col.operator("object.forcefield_toggle", text="Force Field", icon='FORCE_FORCE')
+            col.operator("object.forcefield_toggle", text=_("Force Field"), icon='FORCE_FORCE')
         else:
-            col.operator("object.forcefield_toggle", text="Force Field", icon='X')
+            col.operator("object.forcefield_toggle", text=_("Force Field"), icon='X')
 
         if(ob.type == 'MESH'):
-            physics_add(self, col, context.collision, "Collision", 'COLLISION', 'MOD_PHYSICS', False)
-            physics_add(self, col, context.cloth, "Cloth", 'CLOTH', 'MOD_CLOTH', True)
+            physics_add(self, col, context.collision, _("Collision"), 'COLLISION', 'MOD_PHYSICS', False)
+            physics_add(self, col, context.cloth, _("Cloth"), 'CLOTH', 'MOD_CLOTH', True)
 
         col = split.column()
 
         if(ob.type == 'MESH' or ob.type == 'LATTICE'or ob.type == 'CURVE'):
-            physics_add(self, col, context.soft_body, "Soft Body", 'SOFT_BODY', 'MOD_SOFT', True)
+            physics_add(self, col, context.soft_body, _("Soft Body"), 'SOFT_BODY', 'MOD_SOFT', True)
 
         if(ob.type == 'MESH'):
-            physics_add(self, col, context.fluid, "Fluid", 'FLUID_SIMULATION', 'MOD_FLUIDSIM', True)
-            physics_add(self, col, context.smoke, "Smoke", 'SMOKE', 'MOD_SMOKE', True)
+            physics_add(self, col, context.fluid, _("Fluid"), 'FLUID_SIMULATION', 'MOD_FLUIDSIM', True)
+            physics_add(self, col, context.smoke, _("Smoke"), 'SMOKE', 'MOD_SMOKE', True)
 
 
 #cachetype can be 'PSYS' 'HAIR' 'SMOKE' etc
@@ -95,11 +95,11 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
 
     if cache.use_external:
         split = layout.split(percentage=0.80)
-        split.prop(cache, "name", text="File Name")
+        split.prop(cache, "name", text=_("File Name"))
         split.prop(cache, "index", text="")
 
         row = layout.row()
-        row.label(text="File Path:")
+        row.label(text=_("File Path:"))
         row.prop(cache, "use_library_path", "Use Lib Path")
 
         layout.prop(cache, "filepath", text="")
@@ -108,13 +108,13 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
     else:
         if cachetype == 'SMOKE':
             if not bpy.data.is_saved:
-                layout.label(text="Cache is disabled until the file is saved")
+                layout.label(text=_("Cache is disabled until the file is saved"))
                 layout.enabled = False
 
         if cache.use_disk_cache:
-            layout.prop(cache, "name", text="File Name")
+            layout.prop(cache, "name", text=_("File Name"))
         else:
-            layout.prop(cache, "name", text="Cache Name")
+            layout.prop(cache, "name", text=_("Cache Name"))
 
         row = layout.row(align=True)
 
@@ -142,7 +142,7 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
             row = layout.row()
             row.enabled = enabled and bpy.data.is_saved
             row.active = cache.use_disk_cache
-            row.label(text="Compression:")
+            row.label(text=_("Compression:"))
             row.prop(cache, "compression", expand=True)
 
         layout.separator()
@@ -152,22 +152,22 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
         col = split.column()
 
         if cache.is_baked == True:
-            col.operator("ptcache.free_bake", text="Free Bake")
+            col.operator("ptcache.free_bake", text=_("Free Bake"))
         else:
-            col.operator("ptcache.bake", text="Bake").bake = True
+            col.operator("ptcache.bake", text=_("Bake")).bake = True
 
         sub = col.row()
         sub.enabled = (cache.frames_skipped or cache.is_outdated) and enabled
-        sub.operator("ptcache.bake", text="Calculate To Frame").bake = False
+        sub.operator("ptcache.bake", text=_("Calculate To Frame")).bake = False
 
         sub = col.column()
         sub.enabled = enabled
-        sub.operator("ptcache.bake_from_cache", text="Current Cache to Bake")
+        sub.operator("ptcache.bake_from_cache", text=_("Current Cache to Bake"))
 
         col = split.column()
-        col.operator("ptcache.bake_all", text="Bake All Dynamics").bake = True
-        col.operator("ptcache.free_bake_all", text="Free All Bakes")
-        col.operator("ptcache.bake_all", text="Update All To Frame").bake = False
+        col.operator("ptcache.bake_all", text=_("Bake All Dynamics")).bake = True
+        col.operator("ptcache.free_bake_all", text=_("Free All Bakes"))
+        col.operator("ptcache.bake_all", text=_("Update All To Frame")).bake = False
 
 
 def effector_weights_ui(self, context, weights):
@@ -215,7 +215,7 @@ def basic_force_field_settings_ui(self, context, field):
     col = split.column()
 
     if field.type == 'DRAG':
-        col.prop(field, "linear_drag", text="Linear")
+        col.prop(field, "linear_drag", text=_("Linear"))
     else:
         col.prop(field, "strength")
 
@@ -223,12 +223,12 @@ def basic_force_field_settings_ui(self, context, field):
         col.prop(field, "size")
         col.prop(field, "flow")
     elif field.type == 'HARMONIC':
-        col.prop(field, "harmonic_damping", text="Damping")
+        col.prop(field, "harmonic_damping", text=_("Damping"))
         col.prop(field, "rest_length")
     elif field.type == 'VORTEX' and field.shape != 'POINT':
         col.prop(field, "inflow")
     elif field.type == 'DRAG':
-        col.prop(field, "quadratic_drag", text="Quadratic")
+        col.prop(field, "quadratic_drag", text=_("Quadratic"))
     else:
         col.prop(field, "flow")
 
@@ -237,19 +237,19 @@ def basic_force_field_settings_ui(self, context, field):
     sub.prop(field, "noise")
     sub.prop(field, "seed")
     if field.type == 'TURBULENCE':
-        col.prop(field, "use_global_coords", text="Global")
+        col.prop(field, "use_global_coords", text=_("Global"))
     elif field.type == 'HARMONIC':
         col.prop(field, "use_multiple_springs")
 
     split = layout.split()
 
     col = split.column()
-    col.label(text="Effect point:")
+    col.label(text=_("Effect point:"))
     col.prop(field, "apply_to_location")
     col.prop(field, "apply_to_rotation")
 
     col = split.column()
-    col.label(text="Collision:")
+    col.label(text=_("Collision:"))
     col.prop(field, "use_absorption")
 
 
@@ -265,7 +265,7 @@ def basic_force_field_falloff_ui(self, context, field):
     col.prop(field, "z_direction", text="")
 
     col = split.column()
-    col.prop(field, "falloff_power", text="Power")
+    col.prop(field, "falloff_power", text=_("Power"))
 
     split = layout.split()
     col = split.column()
@@ -273,14 +273,14 @@ def basic_force_field_falloff_ui(self, context, field):
     row.prop(field, "use_min_distance", text="")
     sub = row.row()
     sub.active = field.use_min_distance
-    sub.prop(field, "distance_min", text="Minimum")
+    sub.prop(field, "distance_min", text=_("Minimum"))
 
     col = split.column()
     row = col.row(align=True)
     row.prop(field, "use_max_distance", text="")
     sub = row.row()
     sub.active = field.use_max_distance
-    sub.prop(field, "distance_max", text="Maximum")
+    sub.prop(field, "distance_max", text=_("Maximum"))
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)
diff --git a/release/scripts/startup/bl_ui/properties_physics_field.py b/release/scripts/startup/bl_ui/properties_physics_field.py
index e1dc4d04378..937df5c0ad9 100644
--- a/release/scripts/startup/bl_ui/properties_physics_field.py
+++ b/release/scripts/startup/bl_ui/properties_physics_field.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     basic_force_field_settings_ui,
@@ -54,13 +54,13 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
         field = ob.field
 
         split = layout.split(percentage=0.2)
-        split.label(text="Type:")
+        split.label(text=_("Type:"))
 
         split.prop(field, "type", text="")
 
         if field.type not in {'NONE', 'GUIDE', 'TEXTURE'}:
             split = layout.split(percentage=0.2)
-            split.label(text="Shape:")
+            split.label(text=_("Shape:"))
             split.prop(field, "shape", text="")
 
         split = layout.split()
@@ -76,7 +76,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
             col.prop(field, "use_guide_path_weight")
 
             col = split.column()
-            col.label(text="Clumping:")
+            col.label(text=_("Clumping:"))
             col.prop(field, "guide_clump_amount")
             col.prop(field, "guide_clump_shape")
 
@@ -117,7 +117,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
 
         if field.type not in {'NONE', 'GUIDE'}:
 
-            layout.label(text="Falloff:")
+            layout.label(text=_("Falloff:"))
             layout.prop(field, "falloff_type", expand=True)
 
             basic_force_field_falloff_ui(self, context, field)
@@ -128,20 +128,20 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
                 split = layout.split(percentage=0.35)
 
                 col = split.column()
-                col.label(text="Angular:")
-                col.prop(field, "use_radial_min", text="Use Minimum")
-                col.prop(field, "use_radial_max", text="Use Maximum")
+                col.label(text=_("Angular:"))
+                col.prop(field, "use_radial_min", text=_("Use Minimum"))
+                col.prop(field, "use_radial_max", text=_("Use Maximum"))
 
                 col = split.column()
-                col.prop(field, "radial_falloff", text="Power")
+                col.prop(field, "radial_falloff", text=_("Power"))
 
                 sub = col.column()
                 sub.active = field.use_radial_min
-                sub.prop(field, "radial_min", text="Angle")
+                sub.prop(field, "radial_min", text=_("Angle"))
 
                 sub = col.column()
                 sub.active = field.use_radial_max
-                sub.prop(field, "radial_max", text="Angle")
+                sub.prop(field, "radial_max", text=_("Angle"))
 
             elif field.falloff_type == 'TUBE':
                 layout.separator()
@@ -149,20 +149,20 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
                 split = layout.split(percentage=0.35)
 
                 col = split.column()
-                col.label(text="Radial:")
-                col.prop(field, "use_radial_min", text="Use Minimum")
-                col.prop(field, "use_radial_max", text="Use Maximum")
+                col.label(text=_("Radial:"))
+                col.prop(field, "use_radial_min", text=_("Use Minimum"))
+                col.prop(field, "use_radial_max", text=_("Use Maximum"))
 
                 col = split.column()
-                col.prop(field, "radial_falloff", text="Power")
+                col.prop(field, "radial_falloff", text=_("Power"))
 
                 sub = col.column()
                 sub.active = field.use_radial_min
-                sub.prop(field, "radial_min", text="Distance")
+                sub.prop(field, "radial_min", text=_("Distance"))
 
                 sub = col.column()
                 sub.active = field.use_radial_max
-                sub.prop(field, "radial_max", text="Distance")
+                sub.prop(field, "radial_max", text=_("Distance"))
 
 
 class PHYSICS_PT_collision(PhysicButtonsPanel, Panel):
@@ -192,31 +192,31 @@ class PHYSICS_PT_collision(PhysicButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text="Particle:")
+            col.label(text=_("Particle:"))
             col.prop(settings, "permeability", slider=True)
             col.prop(settings, "stickness")
             col.prop(settings, "use_particle_kill")
-            col.label(text="Particle Damping:")
+            col.label(text=_("Particle Damping:"))
             sub = col.column(align=True)
-            sub.prop(settings, "damping_factor", text="Factor", slider=True)
-            sub.prop(settings, "damping_random", text="Random", slider=True)
+            sub.prop(settings, "damping_factor", text=_("Factor"), slider=True)
+            sub.prop(settings, "damping_random", text=_("Random"), slider=True)
 
-            col.label(text="Particle Friction:")
+            col.label(text=_("Particle Friction:"))
             sub = col.column(align=True)
-            sub.prop(settings, "friction_factor", text="Factor", slider=True)
-            sub.prop(settings, "friction_random", text="Random", slider=True)
+            sub.prop(settings, "friction_factor", text=_("Factor"), slider=True)
+            sub.prop(settings, "friction_random", text=_("Random"), slider=True)
 
             col = split.column()
-            col.label(text="Soft Body and Cloth:")
+            col.label(text=_("Soft Body and Cloth:"))
             sub = col.column(align=True)
-            sub.prop(settings, "thickness_outer", text="Outer", slider=True)
-            sub.prop(settings, "thickness_inner", text="Inner", slider=True)
+            sub.prop(settings, "thickness_outer", text=_("Outer"), slider=True)
+            sub.prop(settings, "thickness_inner", text=_("Inner"), slider=True)
 
-            col.label(text="Soft Body Damping:")
-            col.prop(settings, "damping", text="Factor", slider=True)
+            col.label(text=_("Soft Body Damping:"))
+            col.prop(settings, "damping", text=_("Factor"), slider=True)
 
-            col.label(text="Force Fields:")
-            col.prop(settings, "absorption", text="Absorption")
+            col.label(text=_("Force Fields:"))
+            col.prop(settings, "absorption", text=_("Absorption"))
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)
diff --git a/release/scripts/startup/bl_ui/properties_physics_fluid.py b/release/scripts/startup/bl_ui/properties_physics_fluid.py
index 55629e6c6b9..c89d7ec9755 100644
--- a/release/scripts/startup/bl_ui/properties_physics_fluid.py
+++ b/release/scripts/startup/bl_ui/properties_physics_fluid.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 class PhysicButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -46,7 +46,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
 
             row = layout.row()
             if fluid is None:
-                row.label("Built without fluids")
+                row.label(_("Built without fluids"))
                 return
 
             row.prop(fluid, "type")
@@ -58,28 +58,28 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 layout.active = fluid.use
 
             if fluid.type == 'DOMAIN':
-                layout.operator("fluid.bake", text="Bake (Req. Memory: %s)" % fluid.memory_estimate, icon='MOD_FLUIDSIM')
+                layout.operator("fluid.bake", text=_("Bake (Req. Memory:")+" %s)" % fluid.memory_estimate, icon='MOD_FLUIDSIM')
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Resolution:")
-                col.prop(fluid, "resolution", text="Final")
-                col.label(text="Render Display:")
+                col.label(text=_("Resolution:"))
+                col.prop(fluid, "resolution", text=_("Final"))
+                col.label(text=_("Render Display:"))
                 col.prop(fluid, "render_display_mode", text="")
 
                 col = split.column()
                 col.label()
-                col.prop(fluid, "preview_resolution", text="Preview")
-                col.label(text="Viewport Display:")
+                col.prop(fluid, "preview_resolution", text=_("Preview"))
+                col.label(text=_("Viewport Display:"))
                 col.prop(fluid, "viewport_display_mode", text="")
 
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Time:")
+                col.label(text=_("Time:"))
                 sub = col.column(align=True)
-                sub.prop(fluid, "start_time", text="Start")
-                sub.prop(fluid, "end_time", text="End")
+                sub.prop(fluid, "start_time", text=_("Start"))
+                sub.prop(fluid, "end_time", text=_("End"))
 
                 col = split.column()
                 col.label()
@@ -92,36 +92,36 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Volume Initialization:")
+                col.label(text=_("Volume Initialization:"))
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
 
                 col = split.column()
-                col.label(text="Initial Velocity:")
+                col.label(text=_("Initial Velocity:"))
                 col.prop(fluid, "initial_velocity", text="")
 
             elif fluid.type == 'OBSTACLE':
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Volume Initialization:")
+                col.label(text=_("Volume Initialization:"))
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
 
                 col = split.column()
-                col.label(text="Slip Type:")
+                col.label(text=_("Slip Type:"))
                 col.prop(fluid, "slip_type", text="")
                 if fluid.slip_type == 'PARTIALSLIP':
-                    col.prop(fluid, "partial_slip_factor", slider=True, text="Amount")
+                    col.prop(fluid, "partial_slip_factor", slider=True, text=_("Amount"))
 
-                col.label(text="Impact:")
-                col.prop(fluid, "impact_factor", text="Factor")
+                col.label(text=_("Impact:"))
+                col.prop(fluid, "impact_factor", text=_("Factor"))
 
             elif fluid.type == 'INFLOW':
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Volume Initialization:")
+                col.label(text=_("Volume Initialization:"))
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
                 row = col.row()
@@ -129,14 +129,14 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 row.prop(fluid, "use_local_coords")
 
                 col = split.column()
-                col.label(text="Inflow Velocity:")
+                col.label(text=_("Inflow Velocity:"))
                 col.prop(fluid, "inflow_velocity", text="")
 
             elif fluid.type == 'OUTFLOW':
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Volume Initialization:")
+                col.label(text=_("Volume Initialization:"))
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
 
@@ -146,12 +146,12 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Influence:")
-                col.prop(fluid, "particle_influence", text="Size")
-                col.prop(fluid, "alpha_influence", text="Alpha")
+                col.label(text=_("Influence:"))
+                col.prop(fluid, "particle_influence", text=_("Size"))
+                col.prop(fluid, "alpha_influence", text=_("Alpha"))
 
                 col = split.column()
-                col.label(text="Type:")
+                col.label(text=_("Type:"))
                 col.prop(fluid, "use_drops")
                 col.prop(fluid, "use_floats")
                 col.prop(fluid, "show_tracer")
@@ -167,24 +167,24 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 col.prop(fluid, "use_reverse_frames")
 
                 col = split.column()
-                col.label(text="Time:")
+                col.label(text=_("Time:"))
                 sub = col.column(align=True)
-                sub.prop(fluid, "start_time", text="Start")
-                sub.prop(fluid, "end_time", text="End")
+                sub.prop(fluid, "start_time", text=_("Start"))
+                sub.prop(fluid, "end_time", text=_("End"))
 
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Attraction Force:")
+                col.label(text=_("Attraction Force:"))
                 sub = col.column(align=True)
-                sub.prop(fluid, "attraction_strength", text="Strength")
-                sub.prop(fluid, "attraction_radius", text="Radius")
+                sub.prop(fluid, "attraction_strength", text=_("Strength"))
+                sub.prop(fluid, "attraction_radius", text=_("Radius"))
 
                 col = split.column()
-                col.label(text="Velocity Force:")
+                col.label(text=_("Velocity Force:"))
                 sub = col.column(align=True)
-                sub.prop(fluid, "velocity_strength", text="Strength")
-                sub.prop(fluid, "velocity_radius", text="Radius")
+                sub.prop(fluid, "velocity_strength", text=_("Strength"))
+                sub.prop(fluid, "velocity_radius", text=_("Radius"))
 
 
 class PHYSICS_PT_domain_gravity(PhysicButtonsPanel, Panel):
@@ -206,33 +206,33 @@ class PHYSICS_PT_domain_gravity(PhysicButtonsPanel, Panel):
 
         col = split.column()
         if scene.use_gravity:
-            col.label(text="Using Scene Gravity", icon="SCENE_DATA")
+            col.label(text=_("Using Scene Gravity"), icon="SCENE_DATA")
             sub = col.column()
             sub.enabled = False
             sub.prop(fluid, "gravity", text="")
         else:
-            col.label(text="Gravity:")
+            col.label(text=_("Gravity:"))
             col.prop(fluid, "gravity", text="")
 
         if scene.unit_settings.system != 'NONE':
-            col.label(text="Using Scene Size Units", icon="SCENE_DATA")
+            col.label(text=_("Using Scene Size Units"), icon="SCENE_DATA")
             sub = col.column()
             sub.enabled = False
-            sub.prop(fluid, "simulation_scale", text="Metres")
+            sub.prop(fluid, "simulation_scale", text=_("Metres"))
         else:
-            col.label(text="Real World Size:")
-            col.prop(fluid, "simulation_scale", text="Metres")
+            col.label(text=_("Real World Size:"))
+            col.prop(fluid, "simulation_scale", text=_("Metres"))
 
         col = split.column()
-        col.label(text="Viscosity Presets:")
+        col.label(text=_("Viscosity Presets:"))
         sub = col.column(align=True)
         sub.prop(fluid, "viscosity_preset", text="")
 
         if fluid.viscosity_preset == 'MANUAL':
-            sub.prop(fluid, "viscosity_base", text="Base")
-            sub.prop(fluid, "viscosity_exponent", text="Exponent", slider=True)
+            sub.prop(fluid, "viscosity_base", text=_("Base"))
+            sub.prop(fluid, "viscosity_exponent", text=_("Exponent"), slider=True)
 
-        col.label(text="Optimization:")
+        col.label(text=_("Optimization:"))
         col.prop(fluid, "grid_levels", slider=True)
         col.prop(fluid, "compressibility", slider=True)
 
@@ -254,16 +254,16 @@ class PHYSICS_PT_domain_boundary(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Slip Type:")
+        col.label(text=_("Slip Type:"))
         col.prop(fluid, "slip_type", text="")
         if fluid.slip_type == 'PARTIALSLIP':
-            col.prop(fluid, "partial_slip_factor", slider=True, text="Amount")
+            col.prop(fluid, "partial_slip_factor", slider=True, text=_("Amount"))
         col.prop(fluid, "surface_noobs")
 
         col = split.column()
-        col.label(text="Surface:")
-        col.prop(fluid, "surface_smooth", text="Smoothing")
-        col.prop(fluid, "surface_subdivisions", text="Subdivisions")
+        col.label(text=_("Surface:"))
+        col.prop(fluid, "surface_smooth", text=_("Smoothing"))
+        col.prop(fluid, "surface_subdivisions", text=_("Subdivisions"))
 
 
 class PHYSICS_PT_domain_particles(PhysicButtonsPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_physics_smoke.py b/release/scripts/startup/bl_ui/properties_physics_smoke.py
index 771a778380d..61c477b6d49 100644
--- a/release/scripts/startup/bl_ui/properties_physics_smoke.py
+++ b/release/scripts/startup/bl_ui/properties_physics_smoke.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -59,23 +59,23 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
                 split.enabled = not domain.point_cache.is_baked
 
                 col = split.column()
-                col.label(text="Resolution:")
-                col.prop(domain, "resolution_max", text="Divisions")
-                col.label(text="Time:")
-                col.prop(domain, "time_scale", text="Scale")
-                col.label(text="Border Collisions:")
+                col.label(text=_("Resolution:"))
+                col.prop(domain, "resolution_max", text=_("Divisions"))
+                col.label(text=_("Time:"))
+                col.prop(domain, "time_scale", text=_("Scale"))
+                col.label(text=_("Border Collisions:"))
                 col.prop(domain, "collision_extents", text="")
 
                 col = split.column()
-                col.label(text="Behavior:")
+                col.label(text=_("Behavior:"))
                 col.prop(domain, "alpha")
-                col.prop(domain, "beta", text="Temp. Diff.")
+                col.prop(domain, "beta", text=_("Temp. Diff."))
                 col.prop(domain, "vorticity")
-                col.prop(domain, "use_dissolve_smoke", text="Dissolve")
+                col.prop(domain, "use_dissolve_smoke", text=_("Dissolve"))
                 sub = col.column()
                 sub.active = domain.use_dissolve_smoke
-                sub.prop(domain, "dissolve_speed", text="Time")
-                sub.prop(domain, "use_dissolve_smoke_log", text="Slow")
+                sub.prop(domain, "dissolve_speed", text=_("Time"))
+                sub.prop(domain, "use_dissolve_smoke_log", text_("Slow"))
 
             elif md.smoke_type == 'FLOW':
 
@@ -85,20 +85,20 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
 
                 col = split.column()
                 col.prop(flow, "use_outflow")
-                col.label(text="Particle System:")
+                col.label(text=_("Particle System:"))
                 col.prop_search(flow, "particle_system", ob, "particle_systems", text="")
 
                 sub = col.column()
                 sub.active = not md.flow_settings.use_outflow
 
-                sub.prop(flow, "initial_velocity", text="Initial Velocity")
+                sub.prop(flow, "initial_velocity", text=_("Initial Velocity"))
                 sub = sub.column()
                 sub.active = flow.initial_velocity
-                sub.prop(flow, "velocity_factor", text="Multiplier")
+                sub.prop(flow, "velocity_factor", text=_("Multiplier"))
 
                 sub = split.column()
                 sub.active = not md.flow_settings.use_outflow
-                sub.label(text="Initial Values:")
+                sub.label(text=_("Initial Values:"))
                 sub.prop(flow, "use_absolute")
                 sub.prop(flow, "density")
                 sub.prop(flow, "temperature")
@@ -121,14 +121,14 @@ class PHYSICS_PT_smoke_groups(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Flow Group:")
+        col.label(text=_("Flow Group:"))
         col.prop(group, "fluid_group", text="")
 
-        #col.label(text="Effector Group:")
+        #col.label(text=_("Effector Group:"))
         #col.prop(group, "effector_group", text="")
 
         col = split.column()
-        col.label(text="Collision Group:")
+        col.label(text=_("Collision Group:"))
         col.prop(group, "collision_group", text="")
 
 
@@ -157,12 +157,12 @@ class PHYSICS_PT_smoke_highres(PhysicButtonsPanel, Panel):
         split.enabled = not md.point_cache.is_baked
 
         col = split.column()
-        col.label(text="Resolution:")
-        col.prop(md, "amplify", text="Divisions")
+        col.label(text=_("Resolution:"))
+        col.prop(md, "amplify", text=_("Divisions"))
         col.prop(md, "smooth_emitter")
 
         col = split.column()
-        col.label(text="Noise Method:")
+        col.label(text=_("Noise Method:"))
         col.row().prop(md, "noise_type", text="")
         col.prop(md, "strength")
 
@@ -184,7 +184,7 @@ class PHYSICS_PT_smoke_cache(PhysicButtonsPanel, Panel):
         md = context.smoke.domain_settings
         cache = md.point_cache
 
-        layout.label(text="Compression:")
+        layout.label(text=_("Compression:"))
         layout.prop(md, "point_cache_compress_type", expand=True)
 
         point_cache_ui(self, context, cache, (cache.is_baked is False), 'SMOKE')
diff --git a/release/scripts/startup/bl_ui/properties_physics_softbody.py b/release/scripts/startup/bl_ui/properties_physics_softbody.py
index 0b55ccf9516..5449e54c6e6 100644
--- a/release/scripts/startup/bl_ui/properties_physics_softbody.py
+++ b/release/scripts/startup/bl_ui/properties_physics_softbody.py
@@ -19,7 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-
+from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -62,13 +62,13 @@ class PHYSICS_PT_softbody(PhysicButtonsPanel, Panel):
             split.enabled = softbody_panel_enabled(md)
 
             col = split.column()
-            col.label(text="Object:")
+            col.label(text=_("Object:"))
             col.prop(softbody, "friction")
             col.prop(softbody, "mass")
-            col.prop_search(softbody, "vertex_group_mass", ob, "vertex_groups", text="Mass:")
+            col.prop_search(softbody, "vertex_group_mass", ob, "vertex_groups", text=_("Mass:"))
 
             col = split.column()
-            col.label(text="Simulation:")
+            col.label(text=_("Simulation:"))
             col.prop(softbody, "speed")
 
 
@@ -114,18 +114,18 @@ class PHYSICS_PT_softbody_goal(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Goal Strengths:")
-        col.prop(softbody, "goal_default", text="Default")
+        col.label(text=_("Goal Strengths:"))
+        col.prop(softbody, "goal_default", text=_("Default"))
         sub = col.column(align=True)
-        sub.prop(softbody, "goal_min", text="Minimum")
-        sub.prop(softbody, "goal_max", text="Maximum")
+        sub.prop(softbody, "goal_min", text=_("Minimum"))
+        sub.prop(softbody, "goal_max", text=_("Maximum"))
 
         col = split.column()
-        col.label(text="Goal Settings:")
-        col.prop(softbody, "goal_spring", text="Stiffness")
-        col.prop(softbody, "goal_friction", text="Damping")
+        col.label(text=_("Goal Settings:"))
+        col.prop(softbody, "goal_spring", text=_("Stiffness"))
+        col.prop(softbody, "goal_friction", text=_("Damping"))
 
-        layout.prop_search(softbody, "vertex_group_goal", ob, "vertex_groups", text="Vertex Group")
+        layout.prop_search(softbody, "vertex_group_goal", ob, "vertex_groups", text=_("Vertex Group"))
 
 
 class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
@@ -154,14 +154,14 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Springs:")
+        col.label(text=_("Springs:"))
         col.prop(softbody, "pull")
         col.prop(softbody, "push")
         col.prop(softbody, "damping")
         col.prop(softbody, "plastic")
         col.prop(softbody, "bend")
-        col.prop(softbody, "spring_length", text="Length")
-        col.prop_search(softbody, "vertex_group_spring", ob, "vertex_groups", text="Springs:")
+        col.prop(softbody, "spring_length", text=_("Length"))
+        col.prop_search(softbody, "vertex_group_spring", ob, "vertex_groups", text=_("Springs:"))
 
         col = split.column()
         col.prop(softbody, "use_stiff_quads")
@@ -169,16 +169,16 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
         sub.active = softbody.use_stiff_quads
         sub.prop(softbody, "shear")
 
-        col.label(text="Aerodynamics:")
+        col.label(text=_("Aerodynamics:"))
         col.row().prop(softbody, "aerodynamics_type", expand=True)
-        col.prop(softbody, "aero", text="Factor")
+        col.prop(softbody, "aero", text=_("Factor"))
 
         #sub = col.column()
         #sub.enabled = softbody.aero > 0
 
-        col.label(text="Collision:")
-        col.prop(softbody, "use_edge_collision", text="Edge")
-        col.prop(softbody, "use_face_collision", text="Face")
+        col.label(text=_("Collision:"))
+        col.prop(softbody, "use_edge_collision", text=_("Edge"))
+        col.prop(softbody, "use_face_collision", text=_("Face"))
 
 
 class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
@@ -203,14 +203,14 @@ class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
 
         layout.active = softbody.use_self_collision and softbody_panel_enabled(md)
 
-        layout.label(text="Collision Ball Size Calculation:")
+        layout.label(text=_("Collision Ball Size Calculation:"))
         layout.prop(softbody, "collision_type", expand=True)
 
         col = layout.column(align=True)
-        col.label(text="Ball:")
-        col.prop(softbody, "ball_size", text="Size")
-        col.prop(softbody, "ball_stiff", text="Stiffness")
-        col.prop(softbody, "ball_damp", text="Dampening")
+        col.label(text=_("Ball:"))
+        col.prop(softbody, "ball_size", text=_("Size"))
+        col.prop(softbody, "ball_stiff", text=_("Stiffness"))
+        col.prop(softbody, "ball_damp", text=_("Dampening"))
 
 
 class PHYSICS_PT_softbody_solver(PhysicButtonsPanel, Panel):
@@ -233,18 +233,18 @@ class PHYSICS_PT_softbody_solver(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text="Step Size:")
+        col.label(text=_("Step Size:"))
         col.prop(softbody, "step_min")
         col.prop(softbody, "step_max")
-        col.prop(softbody, "use_auto_step", text="Auto-Step")
+        col.prop(softbody, "use_auto_step", text=_("Auto-Step"))
 
         col = split.column()
         col.prop(softbody, "error_threshold")
-        col.label(text="Helpers:")
+        col.label(text=_("Helpers:"))
         col.prop(softbody, "choke")
         col.prop(softbody, "fuzzy")
 
-        layout.label(text="Diagnostics:")
+        layout.label(text=_("Diagnostics:"))
         layout.prop(softbody, "use_diagnose")
         layout.prop(softbody, "use_estimate_matrix")
 
diff --git a/release/scripts/startup/bl_ui/properties_render.py b/release/scripts/startup/bl_ui/properties_render.py
index 395cfc6934e..1e9c15eedae 100644
--- a/release/scripts/startup/bl_ui/properties_render.py
+++ b/release/scripts/startup/bl_ui/properties_render.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Menu, Panel
+from blf import gettext as _
 
 
 class RENDER_MT_presets(Menu):
@@ -64,10 +65,10 @@ class RENDER_PT_render(RenderButtonsPanel, Panel):
         rd = context.scene.render
 
         row = layout.row()
-        row.operator("render.render", text="Image", icon='RENDER_STILL')
-        row.operator("render.render", text="Animation", icon='RENDER_ANIMATION').animation = True
+        row.operator("render.render", text=_("Image"), icon='RENDER_STILL')
+        row.operator("render.render", text=_("Animation"), icon='RENDER_ANIMATION').animation = True
 
-        layout.prop(rd, "display_mode", text="Display")
+        layout.prop(rd, "display_mode", text=_("Display"))
 
 
 class RENDER_PT_layers(RenderButtonsPanel, Panel):
@@ -97,25 +98,25 @@ class RENDER_PT_layers(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(scene, "layers", text="Scene")
+        col.prop(scene, "layers", text=_("Scene"))
         col.label(text="")
-        col.prop(rl, "light_override", text="Light")
-        col.prop(rl, "material_override", text="Material")
+        col.prop(rl, "light_override", text=_("Light"))
+        col.prop(rl, "material_override", text=_("Material"))
 
         col = split.column()
-        col.prop(rl, "layers", text="Layer")
-        col.label(text="Mask Layers:")
+        col.prop(rl, "layers", text=_("Layer"))
+        col.label(text=_("Mask Layers:"))
         col.prop(rl, "layers_zmask", text="")
 
         layout.separator()
-        layout.label(text="Include:")
+        layout.label(text=_("Include:"))
 
         split = layout.split()
 
         col = split.column()
         col.prop(rl, "use_zmask")
         row = col.row()
-        row.prop(rl, "invert_zmask", text="Negate")
+        row.prop(rl, "invert_zmask", text=_("Negate"))
         row.active = rl.use_zmask
         col.prop(rl, "use_all_z")
 
@@ -134,7 +135,7 @@ class RENDER_PT_layers(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Passes:")
+        col.label(text=_("Passes:"))
         col.prop(rl, "use_pass_combined")
         col.prop(rl, "use_pass_z")
         col.prop(rl, "use_pass_vector")
@@ -193,29 +194,29 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text="Resolution:")
+        sub.label(text=_("Resolution:"))
         sub.prop(rd, "resolution_x", text="X")
         sub.prop(rd, "resolution_y", text="Y")
         sub.prop(rd, "resolution_percentage", text="")
 
-        sub.label(text="Aspect Ratio:")
+        sub.label(text=_("Aspect Ratio:"))
         sub.prop(rd, "pixel_aspect_x", text="X")
         sub.prop(rd, "pixel_aspect_y", text="Y")
 
         row = col.row()
-        row.prop(rd, "use_border", text="Border")
+        row.prop(rd, "use_border", text=_("Border"))
         sub = row.row()
         sub.active = rd.use_border
-        sub.prop(rd, "use_crop_to_border", text="Crop")
+        sub.prop(rd, "use_crop_to_border", text=_("Crop"))
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text="Frame Range:")
-        sub.prop(scene, "frame_start", text="Start")
-        sub.prop(scene, "frame_end", text="End")
-        sub.prop(scene, "frame_step", text="Step")
+        sub.label(text=_("Frame Range:"))
+        sub.prop(scene, "frame_start")
+        sub.prop(scene, "frame_end")
+        sub.prop(scene, "frame_step")
 
-        sub.label(text="Frame Rate:")
+        sub.label(text=_("Frame Rate:"))
         if rd.fps_base == 1:
             fps_rate = round(rd.fps / rd.fps_base)
         else:
@@ -225,7 +226,7 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
         custom_framerate = (fps_rate not in {23.98, 24, 25, 29.97, 30, 50, 59.94, 60})
 
         if custom_framerate == True:
-            fps_label_text = "Custom (" + str(fps_rate) + " fps)"
+            fps_label_text = _("Custom (") + str(fps_rate) + " fps)"
         else:
             fps_label_text = str(fps_rate) + " fps"
 
@@ -235,10 +236,10 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
             sub.prop(rd, "fps")
             sub.prop(rd, "fps_base", text="/")
         subrow = sub.row(align=True)
-        subrow.label(text="Time Remapping:")
+        subrow.label(text=_("Time Remapping:"))
         subrow = sub.row(align=True)
-        subrow.prop(rd, "frame_map_old", text="Old")
-        subrow.prop(rd, "frame_map_new", text="New")
+        subrow.prop(rd, "frame_map_old", text=_("Old"))
+        subrow.prop(rd, "frame_map_new", text=_("New"))
 
 
 class RENDER_PT_antialiasing(RenderButtonsPanel, Panel):
@@ -266,7 +267,7 @@ class RENDER_PT_antialiasing(RenderButtonsPanel, Panel):
 
         col = split.column()
         col.prop(rd, "pixel_filter_type", text="")
-        col.prop(rd, "filter_size", text="Size")
+        col.prop(rd, "filter_size", text=_("Size"))
 
 
 class RENDER_PT_motion_blur(RenderButtonsPanel, Panel):
@@ -308,15 +309,15 @@ class RENDER_PT_shading(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "use_textures", text="Textures")
-        col.prop(rd, "use_shadows", text="Shadows")
-        col.prop(rd, "use_sss", text="Subsurface Scattering")
-        col.prop(rd, "use_envmaps", text="Environment Map")
+        col.prop(rd, "use_textures", text=_("Textures"))
+        col.prop(rd, "use_shadows", text=_("Shadows"))
+        col.prop(rd, "use_sss", text=_("Subsurface Scattering"))
+        col.prop(rd, "use_envmaps", text=_("Environment Map"))
 
         col = split.column()
-        col.prop(rd, "use_raytrace", text="Ray Tracing")
+        col.prop(rd, "use_raytrace", text=_("Ray Tracing"))
         col.prop(rd, "use_color_management")
-        col.prop(rd, "alpha_mode", text="Alpha")
+        col.prop(rd, "alpha_mode", text=_("Alpha"))
 
 
 class RENDER_PT_performance(RenderButtonsPanel, Panel):
@@ -332,18 +333,18 @@ class RENDER_PT_performance(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Threads:")
+        col.label(text=_("Threads:"))
         col.row().prop(rd, "threads_mode", expand=True)
         sub = col.column()
         sub.enabled = rd.threads_mode == 'FIXED'
         sub.prop(rd, "threads")
         sub = col.column(align=True)
-        sub.label(text="Tiles:")
+        sub.label(text=_("Tiles:"))
         sub.prop(rd, "parts_x", text="X")
         sub.prop(rd, "parts_y", text="Y")
 
         col = split.column()
-        col.label(text="Memory:")
+        col.label(text=_("Memory:"))
         sub = col.column()
         sub.enabled = not (rd.use_border or rd.use_full_sample)
         sub.prop(rd, "use_save_buffers")
@@ -353,13 +354,13 @@ class RENDER_PT_performance(RenderButtonsPanel, Panel):
         sub.prop(rd, "use_free_unused_nodes")
         sub = col.column()
         sub.active = rd.use_raytrace
-        sub.label(text="Acceleration structure:")
+        sub.label(text=_("Acceleration structure:"))
         sub.prop(rd, "raytrace_method", text="")
         if rd.raytrace_method == 'OCTREE':
-            sub.prop(rd, "octree_resolution", text="Resolution")
+            sub.prop(rd, "octree_resolution", text=_("Resolution"))
         else:
-            sub.prop(rd, "use_instances", text="Instances")
-        sub.prop(rd, "use_local_coords", text="Local Coordinates")
+            sub.prop(rd, "use_instances", text=_("Instances"))
+        sub.prop(rd, "use_local_coords", text=_("Local Coordinates"))
 
 
 class RENDER_PT_post_processing(RenderButtonsPanel, Panel):
@@ -378,24 +379,24 @@ class RENDER_PT_post_processing(RenderButtonsPanel, Panel):
         col.prop(rd, "use_compositing")
         col.prop(rd, "use_sequencer")
 
-        split.prop(rd, "dither_intensity", text="Dither", slider=True)
+        split.prop(rd, "dither_intensity", text=_("Dither"), slider=True)
 
         layout.separator()
 
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "use_fields", text="Fields")
+        col.prop(rd, "use_fields", text=_("Fields"))
         sub = col.column()
         sub.active = rd.use_fields
         sub.row().prop(rd, "field_order", expand=True)
-        sub.prop(rd, "use_fields_still", text="Still")
+        sub.prop(rd, "use_fields_still", text=_("Still"))
 
         col = split.column()
         col.prop(rd, "use_edge_enhance")
         sub = col.column()
         sub.active = rd.use_edge_enhance
-        sub.prop(rd, "edge_threshold", text="Threshold", slider=True)
+        sub.prop(rd, "edge_threshold", text=_("Threshold"), slider=True)
         sub.prop(rd, "edge_color", text="")
 
 
@@ -419,26 +420,26 @@ class RENDER_PT_stamp(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "use_stamp_time", text="Time")
-        col.prop(rd, "use_stamp_date", text="Date")
-        col.prop(rd, "use_stamp_render_time", text="RenderTime")
-        col.prop(rd, "use_stamp_frame", text="Frame")
-        col.prop(rd, "use_stamp_scene", text="Scene")
-        col.prop(rd, "use_stamp_camera", text="Camera")
-        col.prop(rd, "use_stamp_lens", text="Lens")
-        col.prop(rd, "use_stamp_filename", text="Filename")
-        col.prop(rd, "use_stamp_marker", text="Marker")
-        col.prop(rd, "use_stamp_sequencer_strip", text="Seq. Strip")
+        col.prop(rd, "use_stamp_time", text=_("Time"))
+        col.prop(rd, "use_stamp_date", text=_("Date"))
+        col.prop(rd, "use_stamp_render_time", text=_("RenderTime"))
+        col.prop(rd, "use_stamp_frame", text=_("Frame"))
+        col.prop(rd, "use_stamp_scene", text=_("Scene"))
+        col.prop(rd, "use_stamp_camera", text=_("Camera"))
+        col.prop(rd, "use_stamp_lens", text=_("Lens"))
+        col.prop(rd, "use_stamp_filename", text=_("Filename"))
+        col.prop(rd, "use_stamp_marker", text=_("Marker"))
+        col.prop(rd, "use_stamp_sequencer_strip", text=_("Seq. Strip"))
 
         col = split.column()
         col.active = rd.use_stamp
         col.prop(rd, "stamp_foreground", slider=True)
         col.prop(rd, "stamp_background", slider=True)
         col.separator()
-        col.prop(rd, "stamp_font_size", text="Font Size")
+        col.prop(rd, "stamp_font_size", text=_("Font Size"))
 
         row = layout.split(percentage=0.2)
-        row.prop(rd, "use_stamp_note", text="Note")
+        row.prop(rd, "use_stamp_note", text=_("Note"))
         sub = row.row()
         sub.active = rd.use_stamp_note
         sub.prop(rd, "stamp_note_text", text="")
@@ -460,7 +461,7 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
 
         col = split.column()
         col.prop(rd, "file_format", text="")
-        col.row().prop(rd, "color_mode", text="Color", expand=True)
+        col.row().prop(rd, "color_mode", text=_("Color"), expand=True)
 
         col = split.column()
         col.prop(rd, "use_file_extension")
@@ -471,11 +472,11 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
             layout.prop(rd, "file_quality", slider=True)
 
         if file_format == 'PNG':
-            layout.prop(rd, "file_quality", slider=True, text="Compression")
+            layout.prop(rd, "file_quality", slider=True, text=_("Compression"))
 
         if file_format in {'OPEN_EXR', 'MULTILAYER'}:
             row = layout.row()
-            row.prop(rd, "exr_codec", text="Codec")
+            row.prop(rd, "exr_codec", text=_("Codec"))
 
             if file_format == 'OPEN_EXR':
                 row = layout.row()
@@ -486,7 +487,7 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
         elif file_format == 'JPEG2000':
             split = layout.split()
             col = split.column()
-            col.label(text="Depth:")
+            col.label(text=_("Depth:"))
             col.row().prop(rd, "jpeg2k_depth", expand=True)
 
             col = split.column()
@@ -499,13 +500,13 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
             split.label("FIXME: hard coded Non-Linear, Gamma:1.0")
             '''
             col = split.column()
-            col.prop(rd, "use_cineon_log", text="Convert to Log")
+            col.prop(rd, "use_cineon_log", text=_("Convert to Log"))
 
             col = split.column(align=True)
             col.active = rd.use_cineon_log
-            col.prop(rd, "cineon_black", text="Black")
-            col.prop(rd, "cineon_white", text="White")
-            col.prop(rd, "cineon_gamma", text="Gamma")
+            col.prop(rd, "cineon_black", text=_("Black"))
+            col.prop(rd, "cineon_white", text=_("White"))
+            col.prop(rd, "cineon_gamma", text=_("Gamma"))
             '''
 
         elif file_format == 'TIFF':
@@ -517,11 +518,11 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
         elif file_format == 'QUICKTIME_QTKIT':
             split = layout.split()
             col = split.column()
-            col.prop(rd, "quicktime_codec_type", text="Video Codec")
-            col.prop(rd, "quicktime_codec_spatial_quality", text="Quality")
+            col.prop(rd, "quicktime_codec_type", text=_("Video Codec"))
+            col.prop(rd, "quicktime_codec_spatial_quality", text=_("Quality"))
 
             # Audio
-            col.prop(rd, "quicktime_audiocodec_type", text="Audio Codec")
+            col.prop(rd, "quicktime_audiocodec_type", text=_("Audio Codec"))
             if rd.quicktime_audiocodec_type != 'No audio':
                 split = layout.split()
                 if rd.quicktime_audiocodec_type == 'LPCM':
@@ -559,7 +560,7 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
 
         rd = context.scene.render
 
-        layout.menu("RENDER_MT_ffmpeg_presets", text="Presets")
+        layout.menu("RENDER_MT_ffmpeg_presets", text=_("Presets"))
 
         split = layout.split()
         split.prop(rd, "ffmpeg_format")
@@ -575,22 +576,22 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Rate:")
-        col.prop(rd, "ffmpeg_minrate", text="Minimum")
-        col.prop(rd, "ffmpeg_maxrate", text="Maximum")
-        col.prop(rd, "ffmpeg_buffersize", text="Buffer")
+        col.label(text=_("Rate:"))
+        col.prop(rd, "ffmpeg_minrate", text=_("Minimum"))
+        col.prop(rd, "ffmpeg_maxrate", text=_("Maximum"))
+        col.prop(rd, "ffmpeg_buffersize", text=_("Buffer"))
 
         col = split.column()
         col.prop(rd, "ffmpeg_autosplit")
-        col.label(text="Mux:")
-        col.prop(rd, "ffmpeg_muxrate", text="Rate")
-        col.prop(rd, "ffmpeg_packetsize", text="Packet Size")
+        col.label(text=_("Mux:"))
+        col.prop(rd, "ffmpeg_muxrate", text=_("Rate"))
+        col.prop(rd, "ffmpeg_packetsize", text=_("Packet Size"))
 
         layout.separator()
 
         # Audio:
         if rd.ffmpeg_format not in {'MP3'}:
-            layout.prop(rd, "ffmpeg_audio_codec", text="Audio Codec")
+            layout.prop(rd, "ffmpeg_audio_codec", text=_("Audio Codec"))
 
         row = layout.row()
         row.prop(rd, "ffmpeg_audio_bitrate")
@@ -632,7 +633,7 @@ class RENDER_PT_bake(RenderButtonsPanel, Panel):
             col = split.column()
             col.prop(rd, "use_bake_clear")
             col.prop(rd, "bake_margin")
-            col.prop(rd, "bake_quad_split", text="Split")
+            col.prop(rd, "bake_quad_split", text=_("Split"))
 
             col = split.column()
             col.prop(rd, "use_bake_selected_to_active")
diff --git a/release/scripts/startup/bl_ui/properties_scene.py b/release/scripts/startup/bl_ui/properties_scene.py
index 5a25e608a39..c82b4ac69dc 100644
--- a/release/scripts/startup/bl_ui/properties_scene.py
+++ b/release/scripts/startup/bl_ui/properties_scene.py
@@ -20,7 +20,7 @@
 import bpy
 from bpy.types import Operator, Panel
 from rna_prop_ui import PropertyPanel
-
+from blf import gettext as _
 
 class SceneButtonsPanel():
     bl_space_type = 'PROPERTIES'
@@ -41,7 +41,7 @@ class SCENE_PT_scene(SceneButtonsPanel, Panel):
         scene = context.scene
 
         layout.prop(scene, "camera")
-        layout.prop(scene, "background_set", text="Background")
+        layout.prop(scene, "background_set", text=_("Background"))
 
 
 class SCENE_PT_audio(SceneButtonsPanel, Panel):
@@ -59,15 +59,15 @@ class SCENE_PT_audio(SceneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label("Listener:")
+        col.label(_("Listener:"))
         col.prop(scene, "audio_distance_model", text="")
-        col.prop(scene, "audio_doppler_speed", text="Speed")
-        col.prop(scene, "audio_doppler_factor", text="Doppler")
+        col.prop(scene, "audio_doppler_speed", text=_("Speed"))
+        col.prop(scene, "audio_doppler_factor", text=_("Doppler"))
 
         col = split.column()
-        col.label("Format:")
+        col.label(_("Format:"))
         col.prop(rd, "ffmpeg_audio_channels", text="")
-        col.prop(rd, "ffmpeg_audio_mixrate", text="Rate")
+        col.prop(rd, "ffmpeg_audio_mixrate", text=_("Rate"))
 
         layout.operator("sound.mixdown")
 
@@ -86,7 +86,7 @@ class SCENE_PT_unit(SceneButtonsPanel, Panel):
 
         row = layout.row()
         row.active = (unit.system != 'NONE')
-        row.prop(unit, "scale_length", text="Scale")
+        row.prop(unit, "scale_length", text=_("Scale"))
         row.prop(unit, "use_separate")
 
 
@@ -115,11 +115,11 @@ class SCENE_PT_keying_sets(SceneButtonsPanel, Panel):
 
             subcol = col.column()
             subcol.operator_context = 'INVOKE_DEFAULT'
-            op = subcol.operator("anim.keying_set_export", text="Export to File")
+            op = subcol.operator("anim.keying_set_export", text=_("Export to File"))
             op.filepath = "keyingset.py"
 
             col = row.column()
-            col.label(text="Keyframing Settings:")
+            col.label(text=_("Keyframing Settings:"))
             col.prop(ks, "bl_options")
 
 
@@ -138,7 +138,7 @@ class SCENE_PT_keying_set_paths(SceneButtonsPanel, Panel):
         ks = scene.keying_sets.active
 
         row = layout.row()
-        row.label(text="Paths:")
+        row.label(text=_("Paths:"))
 
         row = layout.row()
 
@@ -152,20 +152,20 @@ class SCENE_PT_keying_set_paths(SceneButtonsPanel, Panel):
         ksp = ks.paths.active
         if ksp:
             col = layout.column()
-            col.label(text="Target:")
+            col.label(text=_("Target:"))
             col.template_any_ID(ksp, "id", "id_type")
             col.template_path_builder(ksp, "data_path", ksp.id)
 
             row = layout.row()
 
             col = row.column()
-            col.label(text="Array Target:")
+            col.label(text=_("Array Target:"))
             col.prop(ksp, "use_entire_array")
             if ksp.use_entire_array is False:
                 col.prop(ksp, "array_index")
 
             col = row.column()
-            col.label(text="F-Curve Grouping:")
+            col.label(text=_("F-Curve Grouping:"))
             col.prop(ksp, "group_method")
             if ksp.group_method == 'NAMED':
                 col.prop(ksp, "group")
@@ -209,14 +209,14 @@ class SCENE_PT_simplify(SceneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "simplify_subdivision", text="Subdivision")
-        col.prop(rd, "simplify_child_particles", text="Child Particles")
+        col.prop(rd, "simplify_subdivision", text=_("Subdivision"))
+        col.prop(rd, "simplify_child_particles", text=_("Child Particles"))
 
         col.prop(rd, "use_simplify_triangulate")
 
         col = split.column()
-        col.prop(rd, "simplify_shadow_samples", text="Shadow Samples")
-        col.prop(rd, "simplify_ao_sss", text="AO and SSS")
+        col.prop(rd, "simplify_shadow_samples", text=_("Shadow Samples"))
+        col.prop(rd, "simplify_ao_sss", text=_("AO and SSS"))
 
 
 class SCENE_PT_custom_props(SceneButtonsPanel, PropertyPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_texture.py b/release/scripts/startup/bl_ui/properties_texture.py
index 34f5a948ee7..c5f8708040f 100644
--- a/release/scripts/startup/bl_ui/properties_texture.py
+++ b/release/scripts/startup/bl_ui/properties_texture.py
@@ -20,6 +20,7 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
+from blf import gettext as _
 
 
 class TEXTURE_MT_specials(Menu):
@@ -143,11 +144,11 @@ class TEXTURE_PT_context_texture(TextureButtonsPanel, Panel):
             if tex.use_nodes:
 
                 if slot:
-                    split.label(text="Output:")
+                    split.label(text=_("Output:"))
                     split.prop(slot, "output_node", text="")
 
             else:
-                split.label(text="Type:")
+                split.label(text=_("Type:"))
                 split.prop(tex, "type", text="")
 
 
@@ -178,21 +179,21 @@ class TEXTURE_PT_colors(TextureButtonsPanel, Panel):
 
         tex = context.texture
 
-        layout.prop(tex, "use_color_ramp", text="Ramp")
+        layout.prop(tex, "use_color_ramp", text=_("Ramp"))
         if tex.use_color_ramp:
             layout.template_color_ramp(tex, "color_ramp", expand=True)
 
         split = layout.split()
 
         col = split.column()
-        col.label(text="RGB Multiply:")
+        col.label(text=_("RGB Multiply:"))
         sub = col.column(align=True)
         sub.prop(tex, "factor_red", text="R")
         sub.prop(tex, "factor_green", text="G")
         sub.prop(tex, "factor_blue", text="B")
 
         col = split.column()
-        col.label(text="Adjust:")
+        col.label(text=_("Adjust:"))
         col.prop(tex, "intensity")
         col.prop(tex, "contrast")
         col.prop(tex, "saturation")
@@ -235,17 +236,17 @@ class TEXTURE_PT_clouds(TextureTypePanel, Panel):
         tex = context.texture
 
         layout.prop(tex, "cloud_type", expand=True)
-        layout.label(text="Noise:")
-        layout.prop(tex, "noise_type", text="Type", expand=True)
-        layout.prop(tex, "noise_basis", text="Basis")
+        layout.label(text=_("Noise:"))
+        layout.prop(tex, "noise_type", text=_("Type"), expand=True)
+        layout.prop(tex, "noise_basis", text=_("Basis"))
 
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "noise_scale", text="Size")
-        col.prop(tex, "noise_depth", text="Depth")
+        col.prop(tex, "noise_scale", text=_("Size"))
+        col.prop(tex, "noise_depth", text=_("Depth"))
 
-        split.prop(tex, "nabla", text="Nabla")
+        split.prop(tex, "nabla", text=_("Nabla"))
 
 
 class TEXTURE_PT_wood(TextureTypePanel, Panel):
@@ -263,15 +264,15 @@ class TEXTURE_PT_wood(TextureTypePanel, Panel):
 
         col = layout.column()
         col.active = tex.wood_type in {'RINGNOISE', 'BANDNOISE'}
-        col.label(text="Noise:")
-        col.row().prop(tex, "noise_type", text="Type", expand=True)
-        layout.prop(tex, "noise_basis", text="Basis")
+        col.label(text=_("Noise:"))
+        col.row().prop(tex, "noise_type", text=_("Type"), expand=True)
+        layout.prop(tex, "noise_basis", text=_("Basis"))
 
         split = layout.split()
         split.active = tex.wood_type in {'RINGNOISE', 'BANDNOISE'}
 
         col = split.column()
-        col.prop(tex, "noise_scale", text="Size")
+        col.prop(tex, "noise_scale", text=_("Size"))
         col.prop(tex, "turbulence")
 
         split.prop(tex, "nabla")
@@ -289,15 +290,15 @@ class TEXTURE_PT_marble(TextureTypePanel, Panel):
 
         layout.prop(tex, "marble_type", expand=True)
         layout.prop(tex, "noise_basis_2", expand=True)
-        layout.label(text="Noise:")
-        layout.prop(tex, "noise_type", text="Type", expand=True)
-        layout.prop(tex, "noise_basis", text="Basis")
+        layout.label(text=_("Noise:"))
+        layout.prop(tex, "noise_type", text=_("Type"), expand=True)
+        layout.prop(tex, "noise_basis", text=_("Basis"))
 
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "noise_scale", text="Size")
-        col.prop(tex, "noise_depth", text="Depth")
+        col.prop(tex, "noise_scale", text=_("Size"))
+        col.prop(tex, "noise_depth", text=_("Depth"))
 
         col = split.column()
         col.prop(tex, "turbulence")
@@ -315,7 +316,7 @@ class TEXTURE_PT_magic(TextureTypePanel, Panel):
         tex = context.texture
 
         row = layout.row()
-        row.prop(tex, "noise_depth", text="Depth")
+        row.prop(tex, "noise_depth", text=_("Depth"))
         row.prop(tex, "turbulence")
 
 
@@ -348,12 +349,12 @@ class TEXTURE_PT_stucci(TextureTypePanel, Panel):
         tex = context.texture
 
         layout.prop(tex, "stucci_type", expand=True)
-        layout.label(text="Noise:")
-        layout.prop(tex, "noise_type", text="Type", expand=True)
-        layout.prop(tex, "noise_basis", text="Basis")
+        layout.label(text=_("Noise:"))
+        layout.prop(tex, "noise_type", text=_("Type"), expand=True)
+        layout.prop(tex, "noise_basis", text=_("Basis"))
 
         row = layout.row()
-        row.prop(tex, "noise_scale", text="Size")
+        row.prop(tex, "noise_scale", text=_("Size"))
         row.prop(tex, "turbulence")
 
 
@@ -371,13 +372,13 @@ class TEXTURE_PT_image(TextureTypePanel, Panel):
 
 
 def texture_filter_common(tex, layout):
-    layout.label(text="Filter:")
+    layout.label(text=_("Filter:"))
     layout.prop(tex, "filter_type", text="")
     if tex.use_mipmap and tex.filter_type in {'AREA', 'EWA', 'FELINE'}:
         if tex.filter_type == 'FELINE':
-            layout.prop(tex, "filter_probes", text="Probes")
+            layout.prop(tex, "filter_probes", text=_("Probes"))
         else:
-            layout.prop(tex, "filter_eccentricity", text="Eccentricity")
+            layout.prop(tex, "filter_eccentricity", text=_("Eccentricity"))
 
     layout.prop(tex, "filter_size")
     layout.prop(tex, "use_filter_size_min")
@@ -399,12 +400,12 @@ class TEXTURE_PT_image_sampling(TextureTypePanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Alpha:")
-        col.prop(tex, "use_alpha", text="Use")
-        col.prop(tex, "use_calculate_alpha", text="Calculate")
-        col.prop(tex, "invert_alpha", text="Invert")
+        col.label(text=_("Alpha:"))
+        col.prop(tex, "use_alpha", text=_("Use"))
+        col.prop(tex, "use_calculate_alpha", text=_("Calculate"))
+        col.prop(tex, "invert_alpha", text=_("Invert"))
         col.separator()
-        col.prop(tex, "use_flip_axis", text="Flip X/Y Axis")
+        col.prop(tex, "use_flip_axis", text=_("Flip X/Y Axis"))
 
         col = split.column()
 
@@ -445,12 +446,12 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, Panel):
 
         if tex.extension == 'REPEAT':
             col = split.column(align=True)
-            col.label(text="Repeat:")
+            col.label(text=_("Repeat:"))
             col.prop(tex, "repeat_x", text="X")
             col.prop(tex, "repeat_y", text="Y")
 
             col = split.column(align=True)
-            col.label(text="Mirror:")
+            col.label(text=_("Mirror:"))
             row = col.row()
             row.prop(tex, "use_mirror_x", text="X")
             row.active = (tex.repeat_x > 1)
@@ -462,11 +463,11 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, Panel):
         elif tex.extension == 'CHECKER':
             col = split.column(align=True)
             row = col.row()
-            row.prop(tex, "use_checker_even", text="Even")
-            row.prop(tex, "use_checker_odd", text="Odd")
+            row.prop(tex, "use_checker_even", text=_("Even"))
+            row.prop(tex, "use_checker_odd", text=_("Odd"))
 
             col = split.column()
-            col.prop(tex, "checker_distance", text="Distance")
+            col.prop(tex, "checker_distance", text=_("Distance"))
 
             layout.separator()
 
@@ -474,12 +475,12 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, Panel):
 
         col = split.column(align=True)
         #col.prop(tex, "crop_rectangle")
-        col.label(text="Crop Minimum:")
+        col.label(text=_("Crop Minimum:"))
         col.prop(tex, "crop_min_x", text="X")
         col.prop(tex, "crop_min_y", text="Y")
 
         col = split.column(align=True)
-        col.label(text="Crop Maximum:")
+        col.label(text=_("Crop Maximum:"))
         col.prop(tex, "crop_max_x", text="X")
         col.prop(tex, "crop_max_y", text="Y")
 
@@ -517,9 +518,9 @@ class TEXTURE_PT_envmap(TextureTypePanel, Panel):
 
             col = split.column(align=True)
 
-            col.label(text="Clipping:")
-            col.prop(env, "clip_start", text="Start")
-            col.prop(env, "clip_end", text="End")
+            col.label(text=_("Clipping:"))
+            col.prop(env, "clip_start", text=_("Start"))
+            col.prop(env, "clip_end", text=_("End"))
 
 
 class TEXTURE_PT_envmap_sampling(TextureTypePanel, Panel):
@@ -551,7 +552,7 @@ class TEXTURE_PT_musgrave(TextureTypePanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "dimension_max", text="Dimension")
+        col.prop(tex, "dimension_max", text=_("Dimension"))
         col.prop(tex, "lacunarity")
         col.prop(tex, "octaves")
 
@@ -560,16 +561,16 @@ class TEXTURE_PT_musgrave(TextureTypePanel, Panel):
         if musgrave_type in {'HETERO_TERRAIN', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL'}:
             col.prop(tex, "offset")
         if musgrave_type in {'MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL'}:
-            col.prop(tex, "noise_intensity", text="Intensity")
+            col.prop(tex, "noise_intensity", text=_("Intensity"))
         if musgrave_type in {'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL'}:
             col.prop(tex, "gain")
 
-        layout.label(text="Noise:")
+        layout.label(text=_("Noise:"))
 
-        layout.prop(tex, "noise_basis", text="Basis")
+        layout.prop(tex, "noise_basis", text=_("Basis"))
 
         row = layout.row()
-        row.prop(tex, "noise_scale", text="Size")
+        row.prop(tex, "noise_scale", text=_("Size"))
         row.prop(tex, "nabla")
 
 
@@ -586,26 +587,26 @@ class TEXTURE_PT_voronoi(TextureTypePanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Distance Metric:")
+        col.label(text=_("Distance Metric:"))
         col.prop(tex, "distance_metric", text="")
         sub = col.column()
         sub.active = tex.distance_metric == 'MINKOVSKY'
-        sub.prop(tex, "minkovsky_exponent", text="Exponent")
-        col.label(text="Coloring:")
+        sub.prop(tex, "minkovsky_exponent", text=_("Exponent"))
+        col.label(text=_("Coloring:"))
         col.prop(tex, "color_mode", text="")
-        col.prop(tex, "noise_intensity", text="Intensity")
+        col.prop(tex, "noise_intensity", text=_("Intensity"))
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text="Feature Weights:")
+        sub.label(text=_("Feature Weights:"))
         sub.prop(tex, "weight_1", text="1", slider=True)
         sub.prop(tex, "weight_2", text="2", slider=True)
         sub.prop(tex, "weight_3", text="3", slider=True)
         sub.prop(tex, "weight_4", text="4", slider=True)
 
-        layout.label(text="Noise:")
+        layout.label(text=_("Noise:"))
         row = layout.row()
-        row.prop(tex, "noise_scale", text="Size")
+        row.prop(tex, "noise_scale", text=_("Size"))
         row.prop(tex, "nabla")
 
 
@@ -620,13 +621,13 @@ class TEXTURE_PT_distortednoise(TextureTypePanel, Panel):
         tex = context.texture
 
         layout.prop(tex, "noise_distortion")
-        layout.prop(tex, "noise_basis", text="Basis")
+        layout.prop(tex, "noise_basis", text=_("Basis"))
 
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "distortion", text="Distortion")
-        col.prop(tex, "noise_scale", text="Size")
+        col.prop(tex, "distortion", text=_("Distortion"))
+        col.prop(tex, "noise_scale", text=_("Size"))
 
         split.prop(tex, "nabla")
 
@@ -693,26 +694,26 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, Panel):
 
         col = split.column()
         if pd.point_source == 'PARTICLE_SYSTEM':
-            col.label(text="Object:")
+            col.label(text=_("Object:"))
             col.prop(pd, "object", text="")
 
             sub = col.column()
             sub.enabled = bool(pd.object)
             if pd.object:
-                sub.label(text="System:")
+                sub.label(text=_("System:"))
                 sub.prop_search(pd, "particle_system", pd.object, "particle_systems", text="")
-            sub.label(text="Cache:")
+            sub.label(text=_("Cache:"))
             sub.prop(pd, "particle_cache_space", text="")
         else:
-            col.label(text="Object:")
+            col.label(text=_("Object:"))
             col.prop(pd, "object", text="")
-            col.label(text="Cache:")
+            col.label(text=_("Cache:"))
             col.prop(pd, "vertex_cache_space", text="")
 
         col.separator()
 
         if pd.point_source == 'PARTICLE_SYSTEM':
-            col.label(text="Color Source:")
+            col.label(text=_("Color Source:"))
             col.prop(pd, "color_source", text="")
             if pd.color_source in {'PARTICLE_SPEED', 'PARTICLE_VELOCITY'}:
                 col.prop(pd, "speed_scale")
@@ -722,7 +723,7 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, Panel):
         col = split.column()
         col.label()
         col.prop(pd, "radius")
-        col.label(text="Falloff:")
+        col.label(text=_("Falloff:"))
         col.prop(pd, "falloff", text="")
         if pd.falloff == 'SOFT':
             col.prop(pd, "falloff_soft")
@@ -733,7 +734,7 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, Panel):
 
         if pd.use_falloff_curve:
             col = layout.column()
-            col.label(text="Falloff Curve")
+            col.label(text=_("Falloff Curve"))
             col.template_curve_mapping(pd, "falloff_curve", brush=False)
 
 
@@ -762,9 +763,9 @@ class TEXTURE_PT_pointdensity_turbulence(TextureButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Influence:")
+        col.label(text=_("Influence:"))
         col.prop(pd, "turbulence_influence", text="")
-        col.label(text="Noise Basis:")
+        col.label(text=_("Noise Basis:"))
         col.prop(pd, "noise_basis", text="")
 
         col = split.column()
@@ -801,7 +802,7 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
         if not isinstance(idblock, bpy.types.Brush):
             split = layout.split(percentage=0.3)
             col = split.column()
-            col.label(text="Coordinates:")
+            col.label(text=_("Coordinates:"))
             col = split.column()
             col.prop(tex, "texture_coords", text="")
 
@@ -810,12 +811,12 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
                 ob = context.object
                 if ob and ob.type == 'MESH':
                     split = layout.split(percentage=0.3)
-                    split.label(text="Mesh:")
+                    split.label(text=_("Mesh:"))
                     split.prop(ob.data, "texco_mesh", text="")
                 """
             elif tex.texture_coords == 'UV':
                 split = layout.split(percentage=0.3)
-                split.label(text="Layer:")
+                split.label(text=_("Layer:"))
                 ob = context.object
                 if ob and ob.type == 'MESH':
                     split.prop_search(tex, "uv_layer", ob.data, "uv_textures", text="")
@@ -824,12 +825,12 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
 
             elif tex.texture_coords == 'OBJECT':
                 split = layout.split(percentage=0.3)
-                split.label(text="Object:")
+                split.label(text=_("Object:"))
                 split.prop(tex, "object", text="")
 
         if isinstance(idblock, bpy.types.Brush):
             if context.sculpt_object:
-                layout.label(text="Brush Mapping:")
+                layout.label(text=_("Brush Mapping:"))
                 layout.prop(tex, "map_mode", expand=True)
 
                 row = layout.row()
@@ -838,7 +839,7 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
         else:
             if isinstance(idblock, bpy.types.Material):
                 split = layout.split(percentage=0.3)
-                split.label(text="Projection:")
+                split.label(text=_("Projection:"))
                 split.prop(tex, "mapping", text="")
 
                 split = layout.split()
@@ -900,111 +901,111 @@ class TEXTURE_PT_influence(TextureSlotPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text="Diffuse:")
-                factor_but(col, "use_map_diffuse", "diffuse_factor", "Intensity")
-                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", "Color")
-                factor_but(col, "use_map_alpha", "alpha_factor", "Alpha")
-                factor_but(col, "use_map_translucency", "translucency_factor", "Translucency")
+                col.label(text=_("Diffuse:"))
+                factor_but(col, "use_map_diffuse", "diffuse_factor", _("Intensity"))
+                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", _("Color"))
+                factor_but(col, "use_map_alpha", "alpha_factor", _("Alpha"))
+                factor_but(col, "use_map_translucency", "translucency_factor", _("Translucency"))
 
-                col.label(text="Specular:")
-                factor_but(col, "use_map_specular", "specular_factor", "Intensity")
-                factor_but(col, "use_map_color_spec", "specular_color_factor", "Color")
-                factor_but(col, "use_map_hardness", "hardness_factor", "Hardness")
+                col.label(text=_("Specular:"))
+                factor_but(col, "use_map_specular", "specular_factor", _("Intensity"))
+                factor_but(col, "use_map_color_spec", "specular_color_factor", _("Color"))
+                factor_but(col, "use_map_hardness", "hardness_factor", _("Hardness"))
 
                 col = split.column()
-                col.label(text="Shading:")
-                factor_but(col, "use_map_ambient", "ambient_factor", "Ambient")
-                factor_but(col, "use_map_emit", "emit_factor", "Emit")
-                factor_but(col, "use_map_mirror", "mirror_factor", "Mirror")
-                factor_but(col, "use_map_raymir", "raymir_factor", "Ray Mirror")
+                col.label(text=_("Shading:"))
+                factor_but(col, "use_map_ambient", "ambient_factor", _("Ambient"))
+                factor_but(col, "use_map_emit", "emit_factor", _("Emit"))
+                factor_but(col, "use_map_mirror", "mirror_factor", _("Mirror"))
+                factor_but(col, "use_map_raymir", "raymir_factor", _("Ray Mirror"))
 
-                col.label(text="Geometry:")
+                col.label(text=_("Geometry:"))
                 # XXX replace 'or' when displacement is fixed to not rely on normal influence value.
-                sub_tmp = factor_but(col, "use_map_normal", "normal_factor", "Normal")
+                sub_tmp = factor_but(col, "use_map_normal", "normal_factor", _("Normal"))
                 sub_tmp.active = (tex.use_map_normal or tex.use_map_displacement)
                 # END XXX
 
-                factor_but(col, "use_map_warp", "warp_factor", "Warp")
-                factor_but(col, "use_map_displacement", "displacement_factor", "Displace")
+                factor_but(col, "use_map_warp", "warp_factor", _("Warp"))
+                factor_but(col, "use_map_displacement", "displacement_factor", _("Displace"))
 
                 #sub = col.column()
                 #sub.active = tex.use_map_translucency or tex.map_emit or tex.map_alpha or tex.map_raymir or tex.map_hardness or tex.map_ambient or tex.map_specularity or tex.map_reflection or tex.map_mirror
-                #sub.prop(tex, "default_value", text="Amount", slider=True)
+                #sub.prop(tex, "default_value", text=_("Amount"), slider=True)
             elif idblock.type == 'HALO':
-                layout.label(text="Halo:")
+                layout.label(text=_("Halo:"))
 
                 split = layout.split()
 
                 col = split.column()
-                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", "Color")
-                factor_but(col, "use_map_alpha", "alpha_factor", "Alpha")
+                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", _("Color"))
+                factor_but(col, "use_map_alpha", "alpha_factor", _("Alpha"))
 
                 col = split.column()
-                factor_but(col, "use_map_raymir", "raymir_factor", "Size")
-                factor_but(col, "use_map_hardness", "hardness_factor", "Hardness")
-                factor_but(col, "use_map_translucency", "translucency_factor", "Add")
+                factor_but(col, "use_map_raymir", "raymir_factor", _("Size"))
+                factor_but(col, "use_map_hardness", "hardness_factor", _("Hardness"))
+                factor_but(col, "use_map_translucency", "translucency_factor", _("Add"))
             elif idblock.type == 'VOLUME':
                 split = layout.split()
 
                 col = split.column()
-                factor_but(col, "use_map_density", "density_factor", "Density")
-                factor_but(col, "use_map_emission", "emission_factor", "Emission")
-                factor_but(col, "use_map_scatter", "scattering_factor", "Scattering")
-                factor_but(col, "use_map_reflect", "reflection_factor", "Reflection")
+                factor_but(col, "use_map_density", "density_factor", _("Density"))
+                factor_but(col, "use_map_emission", "emission_factor", _("Emission"))
+                factor_but(col, "use_map_scatter", "scattering_factor", _("Scattering"))
+                factor_but(col, "use_map_reflect", "reflection_factor", _("Reflection"))
 
                 col = split.column()
                 col.label(text=" ")
-                factor_but(col, "use_map_color_emission", "emission_color_factor", "Emission Color")
-                factor_but(col, "use_map_color_transmission", "transmission_color_factor", "Transmission Color")
-                factor_but(col, "use_map_color_reflection", "reflection_color_factor", "Reflection Color")
+                factor_but(col, "use_map_color_emission", "emission_color_factor", _("Emission Color"))
+                factor_but(col, "use_map_color_transmission", "transmission_color_factor", _("Transmission Color"))
+                factor_but(col, "use_map_color_reflection", "reflection_color_factor", _("Reflection Color"))
 
         elif isinstance(idblock, bpy.types.Lamp):
             split = layout.split()
 
             col = split.column()
-            factor_but(col, "use_map_color", "color_factor", "Color")
+            factor_but(col, "use_map_color", "color_factor", _("Color"))
 
             col = split.column()
-            factor_but(col, "use_map_shadow", "shadow_factor", "Shadow")
+            factor_but(col, "use_map_shadow", "shadow_factor", _("Shadow"))
 
         elif isinstance(idblock, bpy.types.World):
             split = layout.split()
 
             col = split.column()
-            factor_but(col, "use_map_blend", "blend_factor", "Blend")
-            factor_but(col, "use_map_horizon", "horizon_factor", "Horizon")
+            factor_but(col, "use_map_blend", "blend_factor", _("Blend"))
+            factor_but(col, "use_map_horizon", "horizon_factor", _("Horizon"))
 
             col = split.column()
-            factor_but(col, "use_map_zenith_up", "zenith_up_factor", "Zenith Up")
-            factor_but(col, "use_map_zenith_down", "zenith_down_factor", "Zenith Down")
+            factor_but(col, "use_map_zenith_up", "zenith_up_factor", _("Zenith Up"))
+            factor_but(col, "use_map_zenith_down", "zenith_down_factor", _("Zenith Down"))
         elif isinstance(idblock, bpy.types.ParticleSettings):
             split = layout.split()
 
             col = split.column()
-            col.label(text="General:")
-            factor_but(col, "use_map_time", "time_factor", "Time")
-            factor_but(col, "use_map_life", "life_factor", "Lifetime")
-            factor_but(col, "use_map_density", "density_factor", "Density")
-            factor_but(col, "use_map_size", "size_factor", "Size")
+            col.label(text=_("General:"))
+            factor_but(col, "use_map_time", "time_factor", _("Time"))
+            factor_but(col, "use_map_life", "life_factor", _("Lifetime"))
+            factor_but(col, "use_map_density", "density_factor", _("Density"))
+            factor_but(col, "use_map_size", "size_factor", _("Size"))
 
             col = split.column()
-            col.label(text="Physics:")
-            factor_but(col, "use_map_velocity", "velocity_factor", "Velocity")
-            factor_but(col, "use_map_damp", "damp_factor", "Damp")
-            factor_but(col, "use_map_gravity", "gravity_factor", "Gravity")
-            factor_but(col, "use_map_field", "field_factor", "Force Fields")
+            col.label(text=_("Physics:"))
+            factor_but(col, "use_map_velocity", "velocity_factor", _("Velocity"))
+            factor_but(col, "use_map_damp", "damp_factor", _("Damp"))
+            factor_but(col, "use_map_gravity", "gravity_factor", _("Gravity"))
+            factor_but(col, "use_map_field", "field_factor", _("Force Fields"))
 
-            layout.label(text="Hair:")
+            layout.label(text=_("Hair:"))
 
             split = layout.split()
 
             col = split.column()
-            factor_but(col, "use_map_length", "length_factor", "Length")
-            factor_but(col, "use_map_clump", "clump_factor", "Clump")
+            factor_but(col, "use_map_length", "length_factor", _("Length"))
+            factor_but(col, "use_map_clump", "clump_factor", _("Clump"))
 
             col = split.column()
-            factor_but(col, "use_map_kink", "kink_factor", "Kink")
-            factor_but(col, "use_map_rough", "rough_factor", "Rough")
+            factor_but(col, "use_map_kink", "kink_factor", _("Kink"))
+            factor_but(col, "use_map_rough", "rough_factor", _("Rough"))
 
         layout.separator()
 
@@ -1012,32 +1013,32 @@ class TEXTURE_PT_influence(TextureSlotPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.prop(tex, "blend_type", text="Blend")
+            col.prop(tex, "blend_type", text=_("Blend"))
             col.prop(tex, "use_rgb_to_intensity")
             # color is used on grayscale textures even when use_rgb_to_intensity is disabled.
             col.prop(tex, "color", text="")
 
             col = split.column()
-            col.prop(tex, "invert", text="Negative")
+            col.prop(tex, "invert", text=_("Negative"))
             col.prop(tex, "use_stencil")
 
         if isinstance(idblock, bpy.types.Material) or isinstance(idblock, bpy.types.World):
-            col.prop(tex, "default_value", text="DVar", slider=True)
+            col.prop(tex, "default_value", text=_("DVar"), slider=True)
 
         if isinstance(idblock, bpy.types.Material):
-            layout.label(text="Bump Mapping:")
+            layout.label(text=_("Bump Mapping:"))
 
             # only show bump settings if activated but not for normalmap images
             row = layout.row()
 
             sub = row.row()
             sub.active = (tex.use_map_normal or tex.use_map_warp) and not (tex.texture.type == 'IMAGE' and (tex.texture.use_normal_map or tex.texture.use_derivative_map))
-            sub.prop(tex, "bump_method", text="Method")
+            sub.prop(tex, "bump_method", text=_("Method"))
 
             # the space setting is supported for: derivmaps + bumpmaps (DEFAULT,BEST_QUALITY), not for normalmaps
             sub = row.row()
             sub.active = (tex.use_map_normal or tex.use_map_warp) and not (tex.texture.type == 'IMAGE' and tex.texture.use_normal_map) and ((tex.bump_method in {'BUMP_DEFAULT', 'BUMP_BEST_QUALITY'}) or (tex.texture.type == 'IMAGE' and tex.texture.use_derivative_map))
-            sub.prop(tex, "bump_objectspace", text="Space")
+            sub.prop(tex, "bump_objectspace", text=_("Space"))
 
 
 class TEXTURE_PT_custom_props(TextureButtonsPanel, PropertyPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/properties_world.py b/release/scripts/startup/bl_ui/properties_world.py
index 71ee03296a0..916667ea400 100644
--- a/release/scripts/startup/bl_ui/properties_world.py
+++ b/release/scripts/startup/bl_ui/properties_world.py
@@ -20,6 +20,7 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
+from blf import gettext as _
 
 
 class WorldButtonsPanel():
@@ -115,12 +116,12 @@ class WORLD_PT_ambient_occlusion(WorldButtonsPanel, Panel):
         layout.active = light.use_ambient_occlusion
 
         split = layout.split()
-        split.prop(light, "ao_factor", text="Factor")
+        split.prop(light, "ao_factor", text=_("Factor"))
         split.prop(light, "ao_blend_type", text="")
 
 
 class WORLD_PT_environment_lighting(WorldButtonsPanel, Panel):
-    bl_label = "Environment Lighting"
+    bl_label = _("Environment Lighting")
     COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw_header(self, context):
@@ -134,7 +135,7 @@ class WORLD_PT_environment_lighting(WorldButtonsPanel, Panel):
         layout.active = light.use_environment_light
 
         split = layout.split()
-        split.prop(light, "environment_energy", text="Energy")
+        split.prop(light, "environment_energy", text=_("Energy"))
         split.prop(light, "environment_color", text="")
 
 
@@ -153,11 +154,11 @@ class WORLD_PT_indirect_lighting(WorldButtonsPanel, Panel):
         layout.active = light.use_indirect_light and light.gather_method == 'APPROXIMATE'
 
         split = layout.split()
-        split.prop(light, "indirect_factor", text="Factor")
-        split.prop(light, "indirect_bounces", text="Bounces")
+        split.prop(light, "indirect_factor", text=_("Factor"))
+        split.prop(light, "indirect_bounces", text=_("Bounces"))
 
         if light.gather_method == 'RAYTRACE':
-            layout.label(text="Only works with Approximate gather method")
+            layout.label(text=_("Only works with Approximate gather method"))
 
 
 class WORLD_PT_gather(WorldButtonsPanel, Panel):
@@ -175,18 +176,18 @@ class WORLD_PT_gather(WorldButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text="Attenuation:")
+        col.label(text=_("Attenuation:"))
         if light.gather_method == 'RAYTRACE':
             col.prop(light, "distance")
         col.prop(light, "use_falloff")
         sub = col.row()
         sub.active = light.use_falloff
-        sub.prop(light, "falloff_strength", text="Strength")
+        sub.prop(light, "falloff_strength", text=_("Strength"))
 
         if light.gather_method == 'RAYTRACE':
             col = split.column()
 
-            col.label(text="Sampling:")
+            col.label(text=_("Sampling:"))
             col.prop(light, "sample_method", text="")
 
             sub = col.column()
@@ -201,9 +202,9 @@ class WORLD_PT_gather(WorldButtonsPanel, Panel):
         if light.gather_method == 'APPROXIMATE':
             col = split.column()
 
-            col.label(text="Sampling:")
+            col.label(text=_("Sampling:"))
             col.prop(light, "passes")
-            col.prop(light, "error_threshold", text="Error")
+            col.prop(light, "error_threshold", text=_("Error"))
             col.prop(light, "use_cache")
             col.prop(light, "correction")
 
@@ -257,11 +258,11 @@ class WORLD_PT_stars(WorldButtonsPanel, Panel):
 
         col = split.column()
         col.prop(world.star_settings, "size")
-        col.prop(world.star_settings, "color_random", text="Colors")
+        col.prop(world.star_settings, "color_random", text=_("Colors"))
 
         col = split.column()
-        col.prop(world.star_settings, "distance_min", text="Min. Dist")
-        col.prop(world.star_settings, "average_separation", text="Separation")
+        col.prop(world.star_settings, "distance_min", text=_("Min. Dist"))
+        col.prop(world.star_settings, "average_separation", text=_("Separation"))
 
 
 class WORLD_PT_custom_props(WorldButtonsPanel, PropertyPanel, Panel):
diff --git a/release/scripts/startup/bl_ui/space_console.py b/release/scripts/startup/bl_ui/space_console.py
index cbbefa01a3c..bb0cf6eda2c 100644
--- a/release/scripts/startup/bl_ui/space_console.py
+++ b/release/scripts/startup/bl_ui/space_console.py
@@ -20,6 +20,7 @@
 import bpy
 from bpy.types import Header, Menu, Operator
 from bpy.props import StringProperty
+from blf import gettext as _
 
 
 class CONSOLE_HT_header(Header):
@@ -33,7 +34,7 @@ class CONSOLE_HT_header(Header):
         if context.area.show_menus:
             layout.menu("CONSOLE_MT_console")
 
-        layout.operator("console.autocomplete", text="Autocomplete")
+        layout.operator("console.autocomplete", text=_("Autocomplete"))
 
 
 class CONSOLE_MT_console(Menu):
diff --git a/release/scripts/startup/bl_ui/space_dopesheet.py b/release/scripts/startup/bl_ui/space_dopesheet.py
index 90dcc99e6d7..580a4e7f1b6 100644
--- a/release/scripts/startup/bl_ui/space_dopesheet.py
+++ b/release/scripts/startup/bl_ui/space_dopesheet.py
@@ -20,6 +20,7 @@
 
 import bpy
 from bpy.types import Header, Menu
+from blf import gettext as _
 
 
 #######################################
@@ -117,7 +118,7 @@ class DOPESHEET_HT_header(Header):
                 row.menu("DOPESHEET_MT_gpencil_frame")
 
         layout.prop(st, "mode", text="")
-        layout.prop(st.dopesheet, "show_summary", text="Summary")
+        layout.prop(st.dopesheet, "show_summary", text=_("Summary"))
 
         if st.mode == 'DOPESHEET':
             dopesheet_filter(layout, context)
@@ -153,9 +154,9 @@ class DOPESHEET_MT_view(Menu):
         layout.prop(st, "use_marker_sync")
 
         if st.show_seconds:
-            layout.operator("anim.time_toggle", text="Show Frames")
+            layout.operator("anim.time_toggle", text=_("Show Frames"))
         else:
-            layout.operator("anim.time_toggle", text="Show Seconds")
+            layout.operator("anim.time_toggle", text=_("Show Seconds"))
 
         layout.separator()
         layout.operator("anim.previewrange_set")
@@ -180,22 +181,22 @@ class DOPESHEET_MT_select(Menu):
 
         # This is a bit misleading as the operator's default text is "Select All" while it actually *toggles* All/None
         layout.operator("action.select_all_toggle")
-        layout.operator("action.select_all_toggle", text="Invert Selection").invert = True
+        layout.operator("action.select_all_toggle", text=_("Invert Selection")).invert = True
 
         layout.separator()
         layout.operator("action.select_border")
-        layout.operator("action.select_border", text="Border Axis Range").axis_range = True
+        layout.operator("action.select_border", text=_("Border Axis Range")).axis_range = True
 
         layout.separator()
-        layout.operator("action.select_column", text="Columns on Selected Keys").mode = 'KEYS'
-        layout.operator("action.select_column", text="Column on Current Frame").mode = 'CFRA'
+        layout.operator("action.select_column", text=_("Columns on Selected Keys")).mode = 'KEYS'
+        layout.operator("action.select_column", text=_("Column on Current Frame")).mode = 'CFRA'
 
-        layout.operator("action.select_column", text="Columns on Selected Markers").mode = 'MARKERS_COLUMN'
-        layout.operator("action.select_column", text="Between Selected Markers").mode = 'MARKERS_BETWEEN'
+        layout.operator("action.select_column", text=_("Columns on Selected Markers")).mode = 'MARKERS_COLUMN'
+        layout.operator("action.select_column", text=_("Between Selected Markers")).mode = 'MARKERS_BETWEEN'
 
         layout.separator()
-        layout.operator("action.select_leftright", text="Before Current Frame").mode = 'LEFT'
-        layout.operator("action.select_leftright", text="After Current Frame").mode = 'RIGHT'
+        layout.operator("action.select_leftright", text=_("Before Current Frame")).mode = 'LEFT'
+        layout.operator("action.select_leftright", text=_("After Current Frame")).mode = 'RIGHT'
 
         # FIXME: grease pencil mode isn't supported for these yet, so skip for that mode only
         if context.space_data.mode != 'GPENCIL':
@@ -217,14 +218,14 @@ class DOPESHEET_MT_marker(Menu):
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", "Add Marker")
-        layout.operator("marker.duplicate", text="Duplicate Marker")
-        layout.operator("marker.delete", text="Delete Marker")
+        layout.operator("marker.add", _("Add Marker"))
+        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
+        layout.operator("marker.delete", text=_("Delete Marker"))
 
         layout.separator()
 
-        layout.operator("marker.rename", text="Rename Marker")
-        layout.operator("marker.move", text="Grab/Move Marker")
+        layout.operator("marker.rename", text=_("Rename Marker"))
+        layout.operator("marker.move", text=_("Grab/Move Marker"))
 
         if st.mode in {'ACTION', 'SHAPEKEY'} and st.action:
             layout.separator()
@@ -254,14 +255,14 @@ class DOPESHEET_MT_channel(Menu):
 
         layout.separator()
         layout.operator("anim.channels_editable_toggle")
-        layout.operator_menu_enum("action.extrapolation_type", "type", text="Extrapolation Mode")
+        layout.operator_menu_enum("action.extrapolation_type", "type", text=_("Extrapolation Mode"))
 
         layout.separator()
         layout.operator("anim.channels_expand")
         layout.operator("anim.channels_collapse")
 
         layout.separator()
-        layout.operator_menu_enum("anim.channels_move", "direction", text="Move...")
+        layout.operator_menu_enum("anim.channels_move", "direction", text=_("Move..."))
 
         layout.separator()
         layout.operator("anim.channels_fcurves_enable")
@@ -273,10 +274,10 @@ class DOPESHEET_MT_key(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.menu("DOPESHEET_MT_key_transform", text="Transform")
+        layout.menu("DOPESHEET_MT_key_transform", text=_("Transform"))
 
-        layout.operator_menu_enum("action.snap", "type", text="Snap")
-        layout.operator_menu_enum("action.mirror", "type", text="Mirror")
+        layout.operator_menu_enum("action.snap", "type", text=_("Snap"))
+        layout.operator_menu_enum("action.mirror", "type", text=_("Mirror"))
 
         layout.separator()
         layout.operator("action.keyframe_insert")
@@ -286,9 +287,9 @@ class DOPESHEET_MT_key(Menu):
         layout.operator("action.delete")
 
         layout.separator()
-        layout.operator_menu_enum("action.keyframe_type", "type", text="Keyframe Type")
-        layout.operator_menu_enum("action.handle_type", "type", text="Handle Type")
-        layout.operator_menu_enum("action.interpolation_type", "type", text="Interpolation Mode")
+        layout.operator_menu_enum("action.keyframe_type", "type", text=_("Keyframe Type"))
+        layout.operator_menu_enum("action.handle_type", "type", text=_("Handle Type"))
+        layout.operator_menu_enum("action.interpolation_type", "type", text=_("Interpolation Mode"))
 
         layout.separator()
         layout.operator("action.clean")
@@ -305,10 +306,10 @@ class DOPESHEET_MT_key_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.transform", text="Grab/Move").mode = 'TIME_TRANSLATE'
-        layout.operator("transform.transform", text="Extend").mode = 'TIME_EXTEND'
-        layout.operator("transform.transform", text="Slide").mode = 'TIME_SLIDE'
-        layout.operator("transform.transform", text="Scale").mode = 'TIME_SCALE'
+        layout.operator("transform.transform", text=_("Grab/Move")).mode = 'TIME_TRANSLATE'
+        layout.operator("transform.transform", text=_("Extend")).mode = 'TIME_EXTEND'
+        layout.operator("transform.transform", text=_("Slide")).mode = 'TIME_SLIDE'
+        layout.operator("transform.transform", text=_("Scale")).mode = 'TIME_SCALE'
 
 
 #######################################
@@ -347,7 +348,7 @@ class DOPESHEET_MT_gpencil_frame(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.menu("DOPESHEET_MT_key_transform", text="Transform")
+        layout.menu("DOPESHEET_MT_key_transform", text=_("Transform"))
 
         #layout.operator_menu_enum("action.snap", "type", text="Snap")
         #layout.operator_menu_enum("action.mirror", "type", text="Mirror")
diff --git a/release/scripts/startup/bl_ui/space_graph.py b/release/scripts/startup/bl_ui/space_graph.py
index d4b8c415a7f..fd50d60bd45 100644
--- a/release/scripts/startup/bl_ui/space_graph.py
+++ b/release/scripts/startup/bl_ui/space_graph.py
@@ -20,6 +20,7 @@
 
 import bpy
 from bpy.types import Header, Menu
+from blf import gettext as _
 
 
 class GRAPH_HT_header(Header):
@@ -82,9 +83,9 @@ class GRAPH_MT_view(Menu):
 
         layout.separator()
         if st.show_handles:
-            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_HLT', text="Show All Handles")
+            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_HLT', text=_("Show All Handles"))
         else:
-            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_DEHLT', text="Show All Handles")
+            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_DEHLT', text=_("Show All Handles"))
         layout.prop(st, "use_only_selected_curves_handles")
         layout.prop(st, "use_only_selected_keyframe_handles")
         layout.operator("anim.time_toggle")
@@ -112,23 +113,23 @@ class GRAPH_MT_select(Menu):
 
         # This is a bit misleading as the operator's default text is "Select All" while it actually *toggles* All/None
         layout.operator("graph.select_all_toggle")
-        layout.operator("graph.select_all_toggle", text="Invert Selection").invert = True
+        layout.operator("graph.select_all_toggle", text=_("Invert Selection")).invert = True
 
         layout.separator()
         layout.operator("graph.select_border")
-        layout.operator("graph.select_border", text="Border Axis Range").axis_range = True
-        layout.operator("graph.select_border", text="Border (Include Handles)").include_handles = True
+        layout.operator("graph.select_border", text=_("Border Axis Range")).axis_range = True
+        layout.operator("graph.select_border", text=_("Border (Include Handles)")).include_handles = True
 
         layout.separator()
-        layout.operator("graph.select_column", text="Columns on Selected Keys").mode = 'KEYS'
-        layout.operator("graph.select_column", text="Column on Current Frame").mode = 'CFRA'
+        layout.operator("graph.select_column", text=_("Columns on Selected Keys")).mode = 'KEYS'
+        layout.operator("graph.select_column", text=_("Column on Current Frame")).mode = 'CFRA'
 
-        layout.operator("graph.select_column", text="Columns on Selected Markers").mode = 'MARKERS_COLUMN'
-        layout.operator("graph.select_column", text="Between Selected Markers").mode = 'MARKERS_BETWEEN'
+        layout.operator("graph.select_column", text=_("Columns on Selected Markers")).mode = 'MARKERS_COLUMN'
+        layout.operator("graph.select_column", text=_("Between Selected Markers")).mode = 'MARKERS_BETWEEN'
 
         layout.separator()
-        layout.operator("graph.select_leftright", text="Before Current Frame").mode = 'LEFT'
-        layout.operator("graph.select_leftright", text="After Current Frame").mode = 'RIGHT'
+        layout.operator("graph.select_leftright", text=_("Before Current Frame")).mode = 'LEFT'
+        layout.operator("graph.select_leftright", text=_("After Current Frame")).mode = 'RIGHT'
 
         layout.separator()
         layout.operator("graph.select_more")
@@ -146,14 +147,14 @@ class GRAPH_MT_marker(Menu):
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", "Add Marker")
-        layout.operator("marker.duplicate", text="Duplicate Marker")
-        layout.operator("marker.delete", text="Delete Marker")
+        layout.operator("marker.add", _("Add Marker"))
+        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
+        layout.operator("marker.delete", text=_("Delete Marker"))
 
         layout.separator()
 
-        layout.operator("marker.rename", text="Rename Marker")
-        layout.operator("marker.move", text="Grab/Move Marker")
+        layout.operator("marker.rename", text=_("Rename Marker"))
+        layout.operator("marker.move", text=_("Grab/Move Marker"))
 
         # TODO: pose markers for action edit mode only?
 
@@ -176,14 +177,14 @@ class GRAPH_MT_channel(Menu):
         layout.separator()
         layout.operator("anim.channels_editable_toggle")
         layout.operator("anim.channels_visibility_set")
-        layout.operator_menu_enum("graph.extrapolation_type", "type", text="Extrapolation Mode")
+        layout.operator_menu_enum("graph.extrapolation_type", "type", text=_("Extrapolation Mode"))
 
         layout.separator()
         layout.operator("anim.channels_expand")
         layout.operator("anim.channels_collapse")
 
         layout.separator()
-        layout.operator_menu_enum("anim.channels_move", "direction", text="Move...")
+        layout.operator_menu_enum("anim.channels_move", "direction", text=_("Move..."))
 
         layout.separator()
         layout.operator("anim.channels_fcurves_enable")
@@ -195,10 +196,10 @@ class GRAPH_MT_key(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.menu("GRAPH_MT_key_transform", text="Transform")
+        layout.menu("GRAPH_MT_key_transform", text=_("Transform"))
 
-        layout.operator_menu_enum("graph.snap", "type", text="Snap")
-        layout.operator_menu_enum("graph.mirror", "type", text="Mirror")
+        layout.operator_menu_enum("graph.snap", "type", text=_("Snap"))
+        layout.operator_menu_enum("graph.mirror", "type", text=_("Mirror"))
 
         layout.separator()
         layout.operator("graph.keyframe_insert")
@@ -210,8 +211,8 @@ class GRAPH_MT_key(Menu):
         layout.operator("graph.delete")
 
         layout.separator()
-        layout.operator_menu_enum("graph.handle_type", "type", text="Handle Type")
-        layout.operator_menu_enum("graph.interpolation_type", "type", text="Interpolation Mode")
+        layout.operator_menu_enum("graph.handle_type", "type", text=_("Handle Type"))
+        layout.operator_menu_enum("graph.interpolation_type", "type", text=_("Interpolation Mode"))
 
         layout.separator()
         layout.operator("graph.clean")
@@ -224,7 +225,7 @@ class GRAPH_MT_key(Menu):
         layout.operator("graph.paste")
 
         layout.separator()
-        layout.operator("graph.euler_filter", text="Discontinuity (Euler) Filter")
+        layout.operator("graph.euler_filter", text=_("Discontinuity (Euler) Filter"))
 
 
 class GRAPH_MT_key_transform(Menu):
@@ -233,10 +234,10 @@ class GRAPH_MT_key_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.translate", text="Grab/Move")
-        layout.operator("transform.transform", text="Extend").mode = 'TIME_EXTEND'
-        layout.operator("transform.rotate", text="Rotate")
-        layout.operator("transform.resize", text="Scale")
+        layout.operator("transform.translate", text=_("Grab/Move"))
+        layout.operator("transform.transform", text=_("Extend")).mode = 'TIME_EXTEND'
+        layout.operator("transform.rotate", text=_("Rotate"))
+        layout.operator("transform.resize", text=_("Scale"))
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)
diff --git a/release/scripts/startup/bl_ui/space_image.py b/release/scripts/startup/bl_ui/space_image.py
index 97b5d8457e0..f5be25d14f6 100644
--- a/release/scripts/startup/bl_ui/space_image.py
+++ b/release/scripts/startup/bl_ui/space_image.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
+from blf import gettext as _
 
 
 class BrushButtonsPanel():
@@ -64,7 +65,7 @@ class IMAGE_MT_view(Menu):
         ratios = [[1, 8], [1, 4], [1, 2], [1, 1], [2, 1], [4, 1], [8, 1]]
 
         for a, b in ratios:
-            text = "Zoom %d:%d" % (a, b)
+            text = _("Zoom") + " %d:%d" % (a, b)
             layout.operator("image.view_zoom_ratio", text=text).ratio = a / b
 
         layout.separator()
@@ -92,7 +93,7 @@ class IMAGE_MT_select(Menu):
         layout.separator()
 
         layout.operator("uv.select_all")
-        layout.operator("uv.select_all", text="Inverse").action = 'INVERT'
+        layout.operator("uv.select_all", text=_("Inverse")).action = 'INVERT'
         layout.operator("uv.unlink_selected")
 
         layout.separator()
@@ -122,12 +123,12 @@ class IMAGE_MT_image(Menu):
 
             layout.operator("image.save")
             layout.operator("image.save_as")
-            layout.operator("image.save_as", text="Save a Copy").copy = True
+            layout.operator("image.save_as", text=_("Save a Copy")).copy = True
 
             if ima.source == 'SEQUENCE':
                 layout.operator("image.save_sequence")
 
-            layout.operator("image.external_edit", "Edit Externally")
+            layout.operator("image.external_edit", _("Edit Externally"))
 
             layout.separator()
 
@@ -145,7 +146,7 @@ class IMAGE_MT_image(Menu):
                 # this could be done in operator poll too
                 if ima.is_dirty:
                     if ima.source in {'FILE', 'GENERATED'} and ima.type != 'MULTILAYER':
-                        layout.operator("image.pack", text="Pack As PNG").as_png = True
+                        layout.operator("image.pack", text=_("Pack As PNG")).as_png = True
 
             layout.separator()
 
@@ -158,23 +159,23 @@ class IMAGE_MT_image_invert(Menu):
     def draw(self, context):
         layout = self.layout
 
-        op = layout.operator("image.invert", text="Invert Image Colors")
+        op = layout.operator("image.invert", text=_("Invert Image Colors"))
         op.invert_r = True
         op.invert_g = True
         op.invert_b = True
 
         layout.separator()
 
-        op = layout.operator("image.invert", text="Invert Red Channel")
+        op = layout.operator("image.invert", text=_("Invert Red Channel"))
         op.invert_r = True
 
-        op = layout.operator("image.invert", text="Invert Green Channel")
+        op = layout.operator("image.invert", text=_("Invert Green Channel"))
         op.invert_g = True
 
-        op = layout.operator("image.invert", text="Invert Blue Channel")
+        op = layout.operator("image.invert", text=_("Invert Blue Channel"))
         op.invert_b = True
 
-        op = layout.operator("image.invert", text="Invert Alpha Channel")
+        op = layout.operator("image.invert", text=_("Invert Alpha Channel"))
         op.invert_a = True
 
 
@@ -185,8 +186,8 @@ class IMAGE_MT_uvs_showhide(Menu):
         layout = self.layout
 
         layout.operator("uv.reveal")
-        layout.operator("uv.hide", text="Hide Selected")
-        layout.operator("uv.hide", text="Hide Unselected").unselected = True
+        layout.operator("uv.hide", text=_("Hide Selected"))
+        layout.operator("uv.hide", text=_("Hide Unselected")).unselected = True
 
 
 class IMAGE_MT_uvs_transform(Menu):
@@ -211,14 +212,14 @@ class IMAGE_MT_uvs_snap(Menu):
         layout = self.layout
         layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("uv.snap_selected", text="Selected to Pixels").target = 'PIXELS'
-        layout.operator("uv.snap_selected", text="Selected to Cursor").target = 'CURSOR'
-        layout.operator("uv.snap_selected", text="Selected to Adjacent Unselected").target = 'ADJACENT_UNSELECTED'
+        layout.operator("uv.snap_selected", text=_("Selected to Pixels")).target = 'PIXELS'
+        layout.operator("uv.snap_selected", text=_("Selected to Cursor")).target = 'CURSOR'
+        layout.operator("uv.snap_selected", text=_("Selected to Adjacent Unselected")).target = 'ADJACENT_UNSELECTED'
 
         layout.separator()
 
-        layout.operator("uv.snap_cursor", text="Cursor to Pixels").target = 'PIXELS'
-        layout.operator("uv.snap_cursor", text="Cursor to Selected").target = 'SELECTED'
+        layout.operator("uv.snap_cursor", text=_("Cursor to Pixels")).target = 'PIXELS'
+        layout.operator("uv.snap_cursor", text=_("Cursor to Selected")).target = 'SELECTED'
 
 
 class IMAGE_MT_uvs_mirror(Menu):
@@ -228,8 +229,8 @@ class IMAGE_MT_uvs_mirror(Menu):
         layout = self.layout
         layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("transform.mirror", text="X Axis").constraint_axis[0] = True
-        layout.operator("transform.mirror", text="Y Axis").constraint_axis[1] = True
+        layout.operator("transform.mirror", text=_("X Axis")).constraint_axis[0] = True
+        layout.operator("transform.mirror", text=_("Y Axis")).constraint_axis[1] = True
 
 
 class IMAGE_MT_uvs_weldalign(Menu):
@@ -259,7 +260,7 @@ class IMAGE_MT_uvs(Menu):
 
         layout.prop(uv, "use_live_unwrap")
         layout.operator("uv.unwrap")
-        layout.operator("uv.pin", text="Unpin").clear = True
+        layout.operator("uv.pin", text=_("Unpin")).clear = True
         layout.operator("uv.pin")
 
         layout.separator()
@@ -299,32 +300,32 @@ class IMAGE_MT_uvs_select_mode(Menu):
         # do smart things depending on whether uv_select_sync is on
 
         if toolsettings.use_uv_select_sync:
-            prop = layout.operator("wm.context_set_value", text="Vertex", icon='VERTEXSEL')
+            prop = layout.operator("wm.context_set_value", text=_("Vertex"), icon='VERTEXSEL')
             prop.value = "(True, False, False)"
             prop.data_path = "tool_settings.mesh_select_mode"
 
-            prop = layout.operator("wm.context_set_value", text="Edge", icon='EDGESEL')
+            prop = layout.operator("wm.context_set_value", text=_("Edge"), icon='EDGESEL')
             prop.value = "(False, True, False)"
             prop.data_path = "tool_settings.mesh_select_mode"
 
-            prop = layout.operator("wm.context_set_value", text="Face", icon='FACESEL')
+            prop = layout.operator("wm.context_set_value", text=_("Face"), icon='FACESEL')
             prop.value = "(False, False, True)"
             prop.data_path = "tool_settings.mesh_select_mode"
 
         else:
-            prop = layout.operator("wm.context_set_string", text="Vertex", icon='UV_VERTEXSEL')
+            prop = layout.operator("wm.context_set_string", text=_("Vertex"), icon='UV_VERTEXSEL')
             prop.value = "VERTEX"
             prop.data_path = "tool_settings.uv_select_mode"
 
-            prop = layout.operator("wm.context_set_string", text="Edge", icon='UV_EDGESEL')
+            prop = layout.operator("wm.context_set_string", text=_("Edge"), icon='UV_EDGESEL')
             prop.value = "EDGE"
             prop.data_path = "tool_settings.uv_select_mode"
 
-            prop = layout.operator("wm.context_set_string", text="Face", icon='UV_FACESEL')
+            prop = layout.operator("wm.context_set_string", text=_("Face"), icon='UV_FACESEL')
             prop.value = "FACE"
             prop.data_path = "tool_settings.uv_select_mode"
 
-            prop = layout.operator("wm.context_set_string", text="Island", icon='UV_ISLANDSEL')
+            prop = layout.operator("wm.context_set_string", text=_("Island"), icon='UV_ISLANDSEL')
             prop.value = "ISLAND"
             prop.data_path = "tool_settings.uv_select_mode"
 
@@ -356,9 +357,9 @@ class IMAGE_HT_header(Header):
                 sub.menu("IMAGE_MT_select")
 
             if ima and ima.is_dirty:
-                sub.menu("IMAGE_MT_image", text="Image*")
+                sub.menu("IMAGE_MT_image", text=_("Image*"))
             else:
-                sub.menu("IMAGE_MT_image", text="Image")
+                sub.menu("IMAGE_MT_image", text=_("Image"))
 
             if show_uvedit:
                 sub.menu("IMAGE_MT_uvs")
@@ -596,22 +597,22 @@ class IMAGE_PT_view_properties(Panel):
 
         col = split.column()
         if ima:
-            col.prop(ima, "display_aspect", text="Aspect Ratio")
+            col.prop(ima, "display_aspect", text=_("Aspect Ratio"))
 
             col = split.column()
-            col.label(text="Coordinates:")
-            col.prop(sima, "show_repeat", text="Repeat")
+            col.label(text=_("Coordinates:"))
+            col.prop(sima, "show_repeat", text=_("Repeat"))
             if show_uvedit:
-                col.prop(uvedit, "show_normalized_coords", text="Normalized")
+                col.prop(uvedit, "show_normalized_coords", text=_("Normalized"))
 
         elif show_uvedit:
-            col.label(text="Coordinates:")
-            col.prop(uvedit, "show_normalized_coords", text="Normalized")
+            col.label(text=_("Coordinates:"))
+            col.prop(uvedit, "show_normalized_coords", text=_("Normalized"))
 
         if show_uvedit:
 
             col = layout.column()
-            col.label("Cursor Location:")
+            col.label(_("Cursor Location:"))
             col.row().prop(uvedit, "cursor_location", text="")
 
             col.separator()
@@ -623,11 +624,11 @@ class IMAGE_PT_view_properties(Panel):
 
             col = split.column()
             col.prop(uvedit, "show_faces")
-            col.prop(uvedit, "show_smooth_edges", text="Smooth")
-            col.prop(uvedit, "show_modified_edges", text="Modified")
+            col.prop(uvedit, "show_smooth_edges", text=_("Smooth"))
+            col.prop(uvedit, "show_modified_edges", text=_("Modified"))
 
             col = split.column()
-            col.prop(uvedit, "show_stretch", text="Stretch")
+            col.prop(uvedit, "show_stretch", text=_("Stretch"))
             sub = col.column()
             sub.active = uvedit.show_stretch
             sub.row().prop(uvedit, "draw_stretch_type", expand=True)
@@ -669,12 +670,12 @@ class IMAGE_PT_paint(Panel):
             row.prop(brush, "jitter", slider=True)
             row.prop(brush, "use_pressure_jitter", toggle=True, text="")
 
-            col.prop(brush, "blend", text="Blend")
+            col.prop(brush, "blend", text=_("Blend"))
 
             if brush.image_tool == 'CLONE':
                 col.separator()
-                col.prop(brush, "clone_image", text="Image")
-                col.prop(brush, "clone_alpha", text="Alpha")
+                col.prop(brush, "clone_image", text=_("Image"))
+                col.prop(brush, "clone_alpha", text=_("Alpha"))
 
 
 class IMAGE_PT_tools_brush_texture(BrushButtonsPanel, Panel):
@@ -728,7 +729,7 @@ class IMAGE_PT_paint_stroke(BrushButtonsPanel, Panel):
         layout.prop(brush, "use_space")
         row = layout.row(align=True)
         row.active = brush.use_space
-        row.prop(brush, "spacing", text="Distance", slider=True)
+        row.prop(brush, "spacing", text=_("Distance"), slider=True)
         row.prop(brush, "use_pressure_spacing", toggle=True, text="")
 
         layout.prop(brush, "use_wrap")
diff --git a/release/scripts/startup/bl_ui/space_info.py b/release/scripts/startup/bl_ui/space_info.py
index debe82e7ab2..3e6abaa8ea3 100644
--- a/release/scripts/startup/bl_ui/space_info.py
+++ b/release/scripts/startup/bl_ui/space_info.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Operator
+from blf import gettext as _
 
 
 class INFO_HT_header(Header):
@@ -45,7 +46,7 @@ class INFO_HT_header(Header):
             sub.menu("INFO_MT_help")
 
         if window.screen.show_fullscreen:
-            layout.operator("screen.back_to_previous", icon='SCREEN_BACK', text="Back to Previous")
+            layout.operator("screen.back_to_previous", icon='SCREEN_BACK', text=_("Back to Previous"))
             layout.separator()
         else:
             layout.template_ID(context.window, "screen", new="screen.new", unlink="screen.delete")
@@ -73,11 +74,11 @@ class INFO_HT_header(Header):
         """
         sinfo = context.space_data
         row = layout.row(align=True)
-        row.prop(sinfo, "show_report_debug", text="Debug")
-        row.prop(sinfo, "show_report_info", text="Info")
-        row.prop(sinfo, "show_report_operator", text="Operators")
-        row.prop(sinfo, "show_report_warning", text="Warnings")
-        row.prop(sinfo, "show_report_error", text="Errors")
+        row.prop(sinfo, "show_report_debug", text=_("Debug"))
+        row.prop(sinfo, "show_report_info", text=_("Info"))
+        row.prop(sinfo, "show_report_operator", text=_("Operators"))
+        row.prop(sinfo, "show_report_warning", text=_("Warnings"))
+        row.prop(sinfo, "show_report_error", text=_("Errors"))
 
         row = layout.row()
         row.enabled = sinfo.show_report_operator
@@ -106,25 +107,25 @@ class INFO_MT_file(Menu):
         layout = self.layout
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("wm.read_homefile", text="New", icon='NEW')
+        layout.operator("wm.read_homefile", text=_("New"), icon='NEW')
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.open_mainfile", text="Open...", icon='FILE_FOLDER')
+        layout.operator("wm.open_mainfile", text=_("Open..."), icon='FILE_FOLDER')
         layout.menu("INFO_MT_file_open_recent")
         layout.operator("wm.recover_last_session", icon='RECOVER_LAST')
-        layout.operator("wm.recover_auto_save", text="Recover Auto Save...")
+        layout.operator("wm.recover_auto_save", text=_("Recover Auto Save..."))
 
         layout.separator()
 
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.save_mainfile", text="Save", icon='FILE_TICK').check_existing = False
+        layout.operator("wm.save_mainfile", text=_("Save"), icon='FILE_TICK').check_existing = False
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.save_as_mainfile", text="Save As...")
+        layout.operator("wm.save_as_mainfile", text=_("Save As..."))
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.save_as_mainfile", text="Save Copy...").copy = True
+        layout.operator("wm.save_as_mainfile", text=_("Save Copy...")).copy = True
 
         layout.separator()
 
-        layout.operator("screen.userpref_show", text="User Preferences...", icon='PREFERENCES')
+        layout.operator("screen.userpref_show", text=_("User Preferences..."), icon='PREFERENCES')
 
         layout.operator_context = 'EXEC_AREA'
         layout.operator("wm.save_homefile")
@@ -133,8 +134,8 @@ class INFO_MT_file(Menu):
         layout.separator()
 
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.link_append", text="Link")
-        props = layout.operator("wm.link_append", text="Append")
+        layout.operator("wm.link_append", text=_("Link"))
+        props = layout.operator("wm.link_append", text=_("Append"))
         props.link = False
         props.instance_groups = False
 
@@ -150,7 +151,7 @@ class INFO_MT_file(Menu):
         layout.separator()
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("wm.quit_blender", text="Quit", icon='QUIT')
+        layout.operator("wm.quit_blender", text=_("Quit"), icon='QUIT')
 
 
 class INFO_MT_file_import(Menu):
@@ -177,8 +178,8 @@ class INFO_MT_file_external_data(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("file.pack_all", text="Pack into .blend file")
-        layout.operator("file.unpack_all", text="Unpack into Files")
+        layout.operator("file.pack_all", text=_("Pack into .blend file"))
+        layout.operator("file.unpack_all", text=_("Unpack into Files"))
 
         layout.separator()
 
@@ -196,17 +197,17 @@ class INFO_MT_mesh_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("mesh.primitive_plane_add", icon='MESH_PLANE', text="Plane")
-        layout.operator("mesh.primitive_cube_add", icon='MESH_CUBE', text="Cube")
-        layout.operator("mesh.primitive_circle_add", icon='MESH_CIRCLE', text="Circle")
-        layout.operator("mesh.primitive_uv_sphere_add", icon='MESH_UVSPHERE', text="UV Sphere")
-        layout.operator("mesh.primitive_ico_sphere_add", icon='MESH_ICOSPHERE', text="Icosphere")
-        layout.operator("mesh.primitive_cylinder_add", icon='MESH_CYLINDER', text="Cylinder")
-        layout.operator("mesh.primitive_cone_add", icon='MESH_CONE', text="Cone")
+        layout.operator("mesh.primitive_plane_add", icon='MESH_PLANE', text=_("Plane"))
+        layout.operator("mesh.primitive_cube_add", icon='MESH_CUBE', text=_("Cube"))
+        layout.operator("mesh.primitive_circle_add", icon='MESH_CIRCLE', text=_("Circle"))
+        layout.operator("mesh.primitive_uv_sphere_add", icon='MESH_UVSPHERE', text=_("UV Sphere"))
+        layout.operator("mesh.primitive_ico_sphere_add", icon='MESH_ICOSPHERE', text=_("Icosphere"))
+        layout.operator("mesh.primitive_cylinder_add", icon='MESH_CYLINDER', text=_("Cylinder"))
+        layout.operator("mesh.primitive_cone_add", icon='MESH_CONE', text=_("Cone"))
         layout.separator()
-        layout.operator("mesh.primitive_grid_add", icon='MESH_GRID', text="Grid")
-        layout.operator("mesh.primitive_monkey_add", icon='MESH_MONKEY', text="Monkey")
-        layout.operator("mesh.primitive_torus_add", text="Torus", icon='MESH_TORUS')
+        layout.operator("mesh.primitive_grid_add", icon='MESH_GRID', text=_("Grid"))
+        layout.operator("mesh.primitive_monkey_add", icon='MESH_MONKEY', text=_("Monkey"))
+        layout.operator("mesh.primitive_torus_add", text=_("Torus"), icon='MESH_TORUS')
 
 
 class INFO_MT_curve_add(Menu):
@@ -217,11 +218,11 @@ class INFO_MT_curve_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("curve.primitive_bezier_curve_add", icon='CURVE_BEZCURVE', text="Bezier")
-        layout.operator("curve.primitive_bezier_circle_add", icon='CURVE_BEZCIRCLE', text="Circle")
-        layout.operator("curve.primitive_nurbs_curve_add", icon='CURVE_NCURVE', text="Nurbs Curve")
-        layout.operator("curve.primitive_nurbs_circle_add", icon='CURVE_NCIRCLE', text="Nurbs Circle")
-        layout.operator("curve.primitive_nurbs_path_add", icon='CURVE_PATH', text="Path")
+        layout.operator("curve.primitive_bezier_curve_add", icon='CURVE_BEZCURVE', text=_("Bezier"))
+        layout.operator("curve.primitive_bezier_circle_add", icon='CURVE_BEZCIRCLE', text=_("Circle"))
+        layout.operator("curve.primitive_nurbs_curve_add", icon='CURVE_NCURVE', text=_("Nurbs Curve"))
+        layout.operator("curve.primitive_nurbs_circle_add", icon='CURVE_NCIRCLE', text=_("Nurbs Circle"))
+        layout.operator("curve.primitive_nurbs_path_add", icon='CURVE_PATH', text=_("Path"))
 
 
 class INFO_MT_edit_curve_add(Menu):
@@ -248,12 +249,12 @@ class INFO_MT_surface_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("surface.primitive_nurbs_surface_curve_add", icon='SURFACE_NCURVE', text="NURBS Curve")
-        layout.operator("surface.primitive_nurbs_surface_circle_add", icon='SURFACE_NCIRCLE', text="NURBS Circle")
-        layout.operator("surface.primitive_nurbs_surface_surface_add", icon='SURFACE_NSURFACE', text="NURBS Surface")
-        layout.operator("surface.primitive_nurbs_surface_cylinder_add", icon='SURFACE_NCYLINDER', text="NURBS Cylinder")
-        layout.operator("surface.primitive_nurbs_surface_sphere_add", icon='SURFACE_NSPHERE', text="NURBS Sphere")
-        layout.operator("surface.primitive_nurbs_surface_torus_add", icon='SURFACE_NTORUS', text="NURBS Torus")
+        layout.operator("surface.primitive_nurbs_surface_curve_add", icon='SURFACE_NCURVE', text=_("NURBS Curve"))
+        layout.operator("surface.primitive_nurbs_surface_circle_add", icon='SURFACE_NCIRCLE', text=_("NURBS Circle"))
+        layout.operator("surface.primitive_nurbs_surface_surface_add", icon='SURFACE_NSURFACE', text=_("NURBS Surface"))
+        layout.operator("surface.primitive_nurbs_surface_cylinder_add", icon='SURFACE_NCYLINDER', text=_("NURBS Cylinder"))
+        layout.operator("surface.primitive_nurbs_surface_sphere_add", icon='SURFACE_NSPHERE', text=_("NURBS Sphere"))
+        layout.operator("surface.primitive_nurbs_surface_torus_add", icon='SURFACE_NTORUS', text=_("NURBS Torus"))
 
 
 class INFO_MT_armature_add(Menu):
@@ -264,7 +265,7 @@ class INFO_MT_armature_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("object.armature_add", text="Single Bone", icon='BONE_DATA')
+        layout.operator("object.armature_add", text=_("Single Bone"), icon='BONE_DATA')
 
 
 class INFO_MT_add(Menu):
@@ -275,39 +276,39 @@ class INFO_MT_add(Menu):
 
         layout.operator_context = 'EXEC_SCREEN'
 
-        #layout.operator_menu_enum("object.mesh_add", "type", text="Mesh", icon='OUTLINER_OB_MESH')
+        #layout.operator_menu_enum("object.mesh_add", "type", text=_("Mesh"), icon='OUTLINER_OB_MESH')
         layout.menu("INFO_MT_mesh_add", icon='OUTLINER_OB_MESH')
 
-        #layout.operator_menu_enum("object.curve_add", "type", text="Curve", icon='OUTLINER_OB_CURVE')
+        #layout.operator_menu_enum("object.curve_add", "type", text=_("Curve"), icon='OUTLINER_OB_CURVE')
         layout.menu("INFO_MT_curve_add", icon='OUTLINER_OB_CURVE')
-        #layout.operator_menu_enum("object.surface_add", "type", text="Surface", icon='OUTLINER_OB_SURFACE')
+        #layout.operator_menu_enum("object.surface_add", "type", text=_("Surface"), icon='OUTLINER_OB_SURFACE')
         layout.menu("INFO_MT_surface_add", icon='OUTLINER_OB_SURFACE')
-        layout.operator_menu_enum("object.metaball_add", "type", text="Metaball", icon='OUTLINER_OB_META')
+        layout.operator_menu_enum("object.metaball_add", "type", text=_("Metaball"), icon='OUTLINER_OB_META')
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("object.text_add", text="Text", icon='OUTLINER_OB_FONT')
+        layout.operator("object.text_add", text=_("Text"), icon='OUTLINER_OB_FONT')
         layout.separator()
 
         layout.menu("INFO_MT_armature_add", icon='OUTLINER_OB_ARMATURE')
-        layout.operator("object.add", text="Lattice", icon='OUTLINER_OB_LATTICE').type = 'LATTICE'
-        layout.operator("object.add", text="Empty", icon='OUTLINER_OB_EMPTY').type = 'EMPTY'
+        layout.operator("object.add", text=_("Lattice"), icon='OUTLINER_OB_LATTICE').type = 'LATTICE'
+        layout.operator("object.add", text=_("Empty"), icon='OUTLINER_OB_EMPTY').type = 'EMPTY'
         layout.separator()
 
-        layout.operator("object.speaker_add", text="Speaker", icon='OUTLINER_OB_SPEAKER')
+        layout.operator("object.speaker_add", text=_("Speaker"), icon='OUTLINER_OB_SPEAKER')
         layout.separator()
 
-        layout.operator("object.camera_add", text="Camera", icon='OUTLINER_OB_CAMERA')
+        layout.operator("object.camera_add", text=_("Camera"), icon='OUTLINER_OB_CAMERA')
         layout.operator_context = 'EXEC_SCREEN'
-        layout.operator_menu_enum("object.lamp_add", "type", text="Lamp", icon='OUTLINER_OB_LAMP')
+        layout.operator_menu_enum("object.lamp_add", "type", text=_("Lamp"), icon='OUTLINER_OB_LAMP')
         layout.separator()
 
-        layout.operator_menu_enum("object.effector_add", "type", text="Force Field", icon='OUTLINER_OB_EMPTY')
+        layout.operator_menu_enum("object.effector_add", "type", text=_("Force Field"), icon='OUTLINER_OB_EMPTY')
         layout.separator()
 
         if(len(bpy.data.groups) > 10):
             layout.operator_context = 'INVOKE_DEFAULT'
-            layout.operator("object.group_instance_add", text="Group Instance...", icon='OUTLINER_OB_EMPTY')
+            layout.operator("object.group_instance_add", text=_("Group Instance..."), icon='OUTLINER_OB_EMPTY')
         else:
-            layout.operator_menu_enum("object.group_instance_add", "group", text="Group Instance", icon='OUTLINER_OB_EMPTY')
+            layout.operator_menu_enum("object.group_instance_add", "group", text=_("Group Instance"), icon='OUTLINER_OB_EMPTY')
 
 
 class INFO_MT_game(Menu):
@@ -337,13 +338,13 @@ class INFO_MT_render(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("render.render", text="Render Image", icon='RENDER_STILL')
-        layout.operator("render.render", text="Render Animation", icon='RENDER_ANIMATION').animation = True
+        layout.operator("render.render", text=_("Render Image"), icon='RENDER_STILL')
+        layout.operator("render.render", text=_("Render Animation"), icon='RENDER_ANIMATION').animation = True
 
         layout.separator()
 
-        layout.operator("render.opengl", text="OpenGL Render Image")
-        layout.operator("render.opengl", text="OpenGL Render Animation").animation = True
+        layout.operator("render.opengl", text=_("OpenGL Render Image"))
+        layout.operator("render.opengl", text=_("OpenGL Render Animation")).animation = True
 
         layout.separator()
 
@@ -359,27 +360,27 @@ class INFO_MT_help(Menu):
 
         layout = self.layout
 
-        layout.operator("wm.url_open", text="Manual", icon='HELP').url = 'http://wiki.blender.org/index.php/Doc:Manual'
-        layout.operator("wm.url_open", text="Release Log", icon='URL').url = 'http://www.blender.org/development/release-logs/blender-259/'
+        layout.operator("wm.url_open", text=_("Manual"), icon='HELP').url = 'http://wiki.blender.org/index.php/Doc:Manual'
+        layout.operator("wm.url_open", text=_("Release Log"), icon='URL').url = 'http://www.blender.org/development/release-logs/blender-259/'
 
         layout.separator()
 
-        layout.operator("wm.url_open", text="Blender Website", icon='URL').url = 'http://www.blender.org/'
-        layout.operator("wm.url_open", text="Blender e-Shop", icon='URL').url = 'http://www.blender.org/e-shop'
-        layout.operator("wm.url_open", text="Developer Community", icon='URL').url = 'http://www.blender.org/community/get-involved/'
-        layout.operator("wm.url_open", text="User Community", icon='URL').url = 'http://www.blender.org/community/user-community/'
+        layout.operator("wm.url_open", text=_("Blender Website"), icon='URL').url = 'http://www.blender.org/'
+        layout.operator("wm.url_open", text=_("Blender e-Shop"), icon='URL').url = 'http://www.blender.org/e-shop'
+        layout.operator("wm.url_open", text=_("Developer Community"), icon='URL').url = 'http://www.blender.org/community/get-involved/'
+        layout.operator("wm.url_open", text=_("User Community"), icon='URL').url = 'http://www.blender.org/community/user-community/'
         layout.separator()
-        layout.operator("wm.url_open", text="Report a Bug", icon='URL').url = 'http://projects.blender.org/tracker/?atid=498&group_id=9&func=browse'
+        layout.operator("wm.url_open", text=_("Report a Bug"), icon='URL').url = 'http://projects.blender.org/tracker/?atid=498&group_id=9&func=browse'
         layout.separator()
 
-        layout.operator("wm.url_open", text="Python API Reference", icon='URL').url = bpy.types.WM_OT_doc_view._prefix
+        layout.operator("wm.url_open", text=_("Python API Reference"), icon='URL').url = bpy.types.WM_OT_doc_view._prefix
         layout.operator("help.operator_cheat_sheet", icon='TEXT')
         layout.operator("wm.sysinfo", icon='TEXT')
         layout.separator()
         if sys.platform[:3] == "win":
             layout.operator("wm.console_toggle", icon='CONSOLE')
             layout.separator()
-        layout.operator("anim.update_data_paths", text="FCurve/Driver Version fix", icon='HELP')
+        layout.operator("anim.update_data_paths", text=_("FCurve/Driver Version fix"), icon='HELP')
         layout.operator("logic.texface_convert", text="TexFace to Material Convert", icon='GAME')
         layout.separator()
         layout.operator("wm.splash", icon='BLENDER')
diff --git a/release/scripts/startup/bl_ui/space_logic.py b/release/scripts/startup/bl_ui/space_logic.py
index 869a91124d3..b1149913d17 100644
--- a/release/scripts/startup/bl_ui/space_logic.py
+++ b/release/scripts/startup/bl_ui/space_logic.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
+from blf import gettext as _
 
 
 class LOGIC_PT_properties(Panel):
@@ -37,7 +38,7 @@ class LOGIC_PT_properties(Panel):
         ob = context.active_object
         game = ob.game
 
-        layout.operator("object.game_property_new", text="Add Game Property", icon='ZOOMIN')
+        layout.operator("object.game_property_new", text=_("Add Game Property"), icon='ZOOMIN')
 
         for i, prop in enumerate(game.properties):
 
@@ -56,9 +57,9 @@ class LOGIC_MT_logicbricks_add(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator_menu_enum("logic.sensor_add", "type", text="Sensor")
-        layout.operator_menu_enum("logic.controller_add", "type", text="Controller")
-        layout.operator_menu_enum("logic.actuator_add", "type", text="Actuator")
+        layout.operator_menu_enum("logic.sensor_add", "type", text=_("Sensor"))
+        layout.operator_menu_enum("logic.controller_add", "type", text=_("Controller"))
+        layout.operator_menu_enum("logic.actuator_add", "type", text=_("Actuator"))
 
 
 class LOGIC_HT_header(Header):
diff --git a/release/scripts/startup/bl_ui/space_nla.py b/release/scripts/startup/bl_ui/space_nla.py
index ffead81c507..8a4b0a61291 100644
--- a/release/scripts/startup/bl_ui/space_nla.py
+++ b/release/scripts/startup/bl_ui/space_nla.py
@@ -20,6 +20,7 @@
 
 import bpy
 from bpy.types import Header, Menu
+from blf import gettext as _
 
 
 class NLA_HT_header(Header):
@@ -62,7 +63,7 @@ class NLA_MT_view(Menu):
         layout.prop(st, "use_realtime_update")
         layout.prop(st, "show_frame_indicator")
 
-        layout.operator("anim.time_toggle", text="Show Frames" if st.show_seconds else "Show Seconds")
+        layout.operator("anim.time_toggle", text=_("Show Frames") if st.show_seconds else _("Show Seconds"))
 
         layout.prop(st, "show_strip_curves")
 
@@ -87,33 +88,33 @@ class NLA_MT_select(Menu):
 
         # This is a bit misleading as the operator's default text is "Select All" while it actually *toggles* All/None
         layout.operator("nla.select_all_toggle")
-        layout.operator("nla.select_all_toggle", text="Invert Selection").invert = True
+        layout.operator("nla.select_all_toggle", text=_("Invert Selection")).invert = True
 
         layout.separator()
         layout.operator("nla.select_border")
-        layout.operator("nla.select_border", text="Border Axis Range").axis_range = True
+        layout.operator("nla.select_border", text=_("Border Axis Range")).axis_range = True
 
         layout.separator()
-        layout.operator("nla.select_leftright", text="Before Current Frame").mode = 'LEFT'
-        layout.operator("nla.select_leftright", text="After Current Frame").mode = 'RIGHT'
+        layout.operator("nla.select_leftright", text=_("Before Current Frame")).mode = 'LEFT'
+        layout.operator("nla.select_leftright", text=_("After Current Frame")).mode = 'RIGHT'
 
 
 class NLA_MT_marker(Menu):
-    bl_label = "Marker"
+    bl_label = _("Marker")
 
     def draw(self, context):
         layout = self.layout
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", "Add Marker")
-        layout.operator("marker.duplicate", text="Duplicate Marker")
-        layout.operator("marker.delete", text="Delete Marker")
+        layout.operator("marker.add", _("Add Marker"))
+        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
+        layout.operator("marker.delete", text=_("Delete Marker"))
 
         layout.separator()
 
-        layout.operator("marker.rename", text="Rename Marker")
-        layout.operator("marker.move", text="Grab/Move Marker")
+        layout.operator("marker.rename", text=_("Rename Marker"))
+        layout.operator("marker.move", text=_("Grab/Move Marker"))
 
 
 class NLA_MT_edit(Menu):
@@ -124,9 +125,9 @@ class NLA_MT_edit(Menu):
 
         scene = context.scene
 
-        layout.menu("NLA_MT_edit_transform", text="Transform")
+        layout.menu("NLA_MT_edit_transform", text=_("Transform"))
 
-        layout.operator_menu_enum("nla.snap", "type", text="Snap")
+        layout.operator_menu_enum("nla.snap", "type", text=_("Snap"))
 
         layout.separator()
         layout.operator("nla.duplicate")
@@ -148,14 +149,14 @@ class NLA_MT_edit(Menu):
 
         # TODO: this really belongs more in a "channel" (or better, "track") menu
         layout.separator()
-        layout.operator_menu_enum("anim.channels_move", "direction", text="Track Ordering...")
+        layout.operator_menu_enum("anim.channels_move", "direction", text=_("Track Ordering..."))
 
         layout.separator()
         # TODO: names of these tools for 'tweakmode' need changing?
         if scene.is_nla_tweakmode:
-            layout.operator("nla.tweakmode_exit", text="Stop Tweaking Strip Actions")
+            layout.operator("nla.tweakmode_exit", text=_("Stop Tweaking Strip Actions"))
         else:
-            layout.operator("nla.tweakmode_enter", text="Start Tweaking Strip Actions")
+            layout.operator("nla.tweakmode_enter", text=_("Start Tweaking Strip Actions"))
 
 
 class NLA_MT_add(Menu):
@@ -174,7 +175,7 @@ class NLA_MT_add(Menu):
 
         layout.separator()
         layout.operator("nla.tracks_add")
-        layout.operator("nla.tracks_add", text="Add Tracks Above Selected").above_selected = True
+        layout.operator("nla.tracks_add", text=_("Add Tracks Above Selected")).above_selected = True
 
 
 class NLA_MT_edit_transform(Menu):
@@ -183,9 +184,9 @@ class NLA_MT_edit_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.translate", text="Grab/Move")
-        layout.operator("transform.transform", text="Extend").mode = 'TIME_EXTEND'
-        layout.operator("transform.transform", text="Scale").mode = 'TIME_SCALE'
+        layout.operator("transform.translate", text=_("Grab/Move"))
+        layout.operator("transform.transform", text=_("Extend")).mode = 'TIME_EXTEND'
+        layout.operator("transform.transform", text=_("Scale")).mode = 'TIME_SCALE'
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)
diff --git a/release/scripts/startup/bl_ui/space_node.py b/release/scripts/startup/bl_ui/space_node.py
index 708017ba749..0808ddf769a 100644
--- a/release/scripts/startup/bl_ui/space_node.py
+++ b/release/scripts/startup/bl_ui/space_node.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
+from blf import gettext as _
 
 
 class NODE_HT_header(Header):
@@ -61,7 +62,7 @@ class NODE_HT_header(Header):
 
         elif snode.tree_type == 'COMPOSITING':
             layout.prop(snode_id, "use_nodes")
-            layout.prop(snode_id.render, "use_free_unused_nodes", text="Free Unused")
+            layout.prop(snode_id.render, "use_free_unused_nodes", text=_("Free Unused"))
             layout.prop(snode, "show_backdrop")
             if snode.show_backdrop:
                 row = layout.row(align=True)
@@ -92,9 +93,9 @@ class NODE_MT_view(Menu):
         if context.space_data.show_backdrop:
             layout.separator()
 
-            layout.operator("node.backimage_move", text="Backdrop move")
-            layout.operator("node.backimage_zoom", text="Backdrop zoom in").factor = 1.2
-            layout.operator("node.backimage_zoom", text="Backdrop zoom out").factor = 0.833
+            layout.operator("node.backimage_move", text=_("Backdrop move"))
+            layout.operator("node.backimage_zoom", text=_("Backdrop zoom in")).factor = 1.2
+            layout.operator("node.backimage_zoom", text=_("Backdrop zoom out")).factor = 0.833
 
         layout.separator()
 
@@ -137,7 +138,7 @@ class NODE_MT_node(Menu):
 
         layout.separator()
         layout.operator("node.link_make")
-        layout.operator("node.link_make", text="Make and Replace Links").replace = True
+        layout.operator("node.link_make", text=_("Make and Replace Links")).replace = True
         layout.operator("node.links_cut")
 
         layout.separator()
@@ -180,13 +181,13 @@ class NODE_PT_properties(Panel):
         snode = context.space_data
         layout.active = snode.show_backdrop
         layout.prop(snode, "backdrop_channels", text="")
-        layout.prop(snode, "backdrop_zoom", text="Zoom")
+        layout.prop(snode, "backdrop_zoom", text=_("Zoom"))
 
         col = layout.column(align=True)
-        col.label(text="Offset:")
+        col.label(text=_("Offset:"))
         col.prop(snode, "backdrop_x", text="X")
         col.prop(snode, "backdrop_y", text="Y")
-        col.operator("node.backimage_move", text="Move")
+        col.operator("node.backimage_move", text=_("Move"))
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)
diff --git a/release/scripts/startup/bl_ui/space_sequencer.py b/release/scripts/startup/bl_ui/space_sequencer.py
index 36f606da635..a9a5eae3179 100644
--- a/release/scripts/startup/bl_ui/space_sequencer.py
+++ b/release/scripts/startup/bl_ui/space_sequencer.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
+from blf import gettext as _
 
 
 def act_strip(context):
@@ -64,9 +65,9 @@ class SEQUENCER_HT_header(Header):
         elif st.view_type == 'SEQUENCER_PREVIEW':
             layout.separator()
             layout.operator("sequencer.refresh_all")
-            layout.prop(st, "display_channel", text="Channel")
+            layout.prop(st, "display_channel", text=_("Channel"))
         else:
-            layout.prop(st, "display_channel", text="Channel")
+            layout.prop(st, "display_channel", text=_("Channel"))
 
             ed = context.scene.sequence_editor
             if ed:
@@ -101,11 +102,11 @@ class SEQUENCER_MT_view(Menu):
         layout.separator()
 
         if st.view_type in {'SEQUENCER', 'SEQUENCER_PREVIEW'}:
-            layout.operator("sequencer.view_all", text='View all Sequences')
+            layout.operator("sequencer.view_all", text=_('View all Sequences'))
         if st.view_type in {'PREVIEW', 'SEQUENCER_PREVIEW'}:
             layout.operator_context = 'INVOKE_REGION_PREVIEW'
-            layout.operator("sequencer.view_all_preview", text='Fit preview in window')
-            layout.operator("sequencer.view_zoom_ratio", text='Show preview 1:1').ratio = 1.0
+            layout.operator("sequencer.view_all_preview", text=_('Fit preview in window'))
+            layout.operator("sequencer.view_zoom_ratio", text=_('Show preview 1:1')).ratio = 1.0
             layout.operator_context = 'INVOKE_DEFAULT'
 
             # # XXX, invokes in the header view
@@ -114,9 +115,9 @@ class SEQUENCER_MT_view(Menu):
         layout.operator("sequencer.view_selected")
 
         if st.show_frames:
-            layout.operator("anim.time_toggle", text="Show Seconds")
+            layout.operator("anim.time_toggle", text=_("Show Seconds"))
         else:
-            layout.operator("anim.time_toggle", text="Show Frames")
+            layout.operator("anim.time_toggle", text=_("Show Frames"))
 
         layout.prop(st, "show_frame_indicator")
         if st.display_mode == 'IMAGE':
@@ -138,12 +139,12 @@ class SEQUENCER_MT_select(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("sequencer.select_active_side", text="Strips to the Left").side = 'LEFT'
-        layout.operator("sequencer.select_active_side", text="Strips to the Right").side = 'RIGHT'
+        layout.operator("sequencer.select_active_side", text=_("Strips to the Left")).side = 'LEFT'
+        layout.operator("sequencer.select_active_side", text=_("Strips to the Right")).side = 'RIGHT'
         layout.separator()
-        layout.operator("sequencer.select_handles", text="Surrounding Handles").side = 'BOTH'
-        layout.operator("sequencer.select_handles", text="Left Handle").side = 'LEFT'
-        layout.operator("sequencer.select_handles", text="Right Handle").side = 'RIGHT'
+        layout.operator("sequencer.select_handles", text=_("Surrounding Handles")).side = 'BOTH'
+        layout.operator("sequencer.select_handles", text=_("Left Handle")).side = 'LEFT'
+        layout.operator("sequencer.select_handles", text=_("Right Handle")).side = 'RIGHT'
         layout.separator()
         layout.operator("sequencer.select_linked")
         layout.operator("sequencer.select_all_toggle")
@@ -158,14 +159,14 @@ class SEQUENCER_MT_marker(Menu):
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", "Add Marker")
-        layout.operator("marker.duplicate", text="Duplicate Marker")
-        layout.operator("marker.delete", text="Delete Marker")
+        layout.operator("marker.add", _("Add Marker"))
+        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
+        layout.operator("marker.delete", text=_("Delete Marker"))
 
         layout.separator()
 
-        layout.operator("marker.rename", text="Rename Marker")
-        layout.operator("marker.move", text="Grab/Move Marker")
+        layout.operator("marker.rename", text=_("Rename Marker"))
+        layout.operator("marker.move", text=_("Grab/Move Marker"))
 
         #layout.operator("sequencer.sound_strip_add", text="Transform Markers") # toggle, will be rna - (sseq->flag & SEQ_MARKER_TRANS)
 
@@ -180,7 +181,7 @@ class SEQUENCER_MT_change(Menu):
 
         layout.operator_menu_enum("sequencer.change_effect_input", "swap")
         layout.operator_menu_enum("sequencer.change_effect_type", "type")
-        layout.operator("sequencer.change_path", text="Path/Files")
+        layout.operator("sequencer.change_path", text=_("Path/Files"))
 
 
 class SEQUENCER_MT_add(Menu):
@@ -192,13 +193,13 @@ class SEQUENCER_MT_add(Menu):
 
         if len(bpy.data.scenes) > 10:
             layout.operator_context = 'INVOKE_DEFAULT'
-            layout.operator("sequencer.scene_strip_add", text="Scene...")
+            layout.operator("sequencer.scene_strip_add", text=_("Scene..."))
         else:
-            layout.operator_menu_enum("sequencer.scene_strip_add", "scene", text="Scene...")
+            layout.operator_menu_enum("sequencer.scene_strip_add", "scene", text=_("Scene..."))
 
-        layout.operator("sequencer.movie_strip_add", text="Movie")
-        layout.operator("sequencer.image_strip_add", text="Image")
-        layout.operator("sequencer.sound_strip_add", text="Sound")
+        layout.operator("sequencer.movie_strip_add", text=_("Movie"))
+        layout.operator("sequencer.image_strip_add", text=_("Image"))
+        layout.operator("sequencer.sound_strip_add", text=_("Sound"))
 
         layout.menu("SEQUENCER_MT_add_effect")
 
@@ -210,22 +211,22 @@ class SEQUENCER_MT_add_effect(Menu):
         layout = self.layout
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("sequencer.effect_strip_add", text="Add").type = 'ADD'
-        layout.operator("sequencer.effect_strip_add", text="Subtract").type = 'SUBTRACT'
-        layout.operator("sequencer.effect_strip_add", text="Alpha Over").type = 'ALPHA_OVER'
-        layout.operator("sequencer.effect_strip_add", text="Alpha Under").type = 'ALPHA_UNDER'
-        layout.operator("sequencer.effect_strip_add", text="Cross").type = 'CROSS'
-        layout.operator("sequencer.effect_strip_add", text="Gamma Cross").type = 'GAMMA_CROSS'
-        layout.operator("sequencer.effect_strip_add", text="Multiply").type = 'MULTIPLY'
-        layout.operator("sequencer.effect_strip_add", text="Over Drop").type = 'OVER_DROP'
-        layout.operator("sequencer.effect_strip_add", text="Plugin").type = 'PLUGIN'
-        layout.operator("sequencer.effect_strip_add", text="Wipe").type = 'WIPE'
-        layout.operator("sequencer.effect_strip_add", text="Glow").type = 'GLOW'
-        layout.operator("sequencer.effect_strip_add", text="Transform").type = 'TRANSFORM'
-        layout.operator("sequencer.effect_strip_add", text="Color").type = 'COLOR'
-        layout.operator("sequencer.effect_strip_add", text="Speed Control").type = 'SPEED'
-        layout.operator("sequencer.effect_strip_add", text="Multicam Selector").type = 'MULTICAM'
-        layout.operator("sequencer.effect_strip_add", text="Adjustment Layer").type = 'ADJUSTMENT'
+        layout.operator("sequencer.effect_strip_add", text=_("Add")).type = 'ADD'
+        layout.operator("sequencer.effect_strip_add", text=_("Subtract")).type = 'SUBTRACT'
+        layout.operator("sequencer.effect_strip_add", text=_("Alpha Over")).type = 'ALPHA_OVER'
+        layout.operator("sequencer.effect_strip_add", text=_("Alpha Under")).type = 'ALPHA_UNDER'
+        layout.operator("sequencer.effect_strip_add", text=_("Cross")).type = 'CROSS'
+        layout.operator("sequencer.effect_strip_add", text=_("Gamma Cross")).type = 'GAMMA_CROSS'
+        layout.operator("sequencer.effect_strip_add", text=_("Multiply")).type = 'MULTIPLY'
+        layout.operator("sequencer.effect_strip_add", text=_("Over Drop")).type = 'OVER_DROP'
+        layout.operator("sequencer.effect_strip_add", text=_("Plugin")).type = 'PLUGIN'
+        layout.operator("sequencer.effect_strip_add", text=_("Wipe")).type = 'WIPE'
+        layout.operator("sequencer.effect_strip_add", text=_("Glow")).type = 'GLOW'
+        layout.operator("sequencer.effect_strip_add", text=_("Transform")).type = 'TRANSFORM'
+        layout.operator("sequencer.effect_strip_add", text=_("Color")).type = 'COLOR'
+        layout.operator("sequencer.effect_strip_add", text=_("Speed Control")).type = 'SPEED'
+        layout.operator("sequencer.effect_strip_add", text=_("Multicam Selector")).type = 'MULTICAM'
+        layout.operator("sequencer.effect_strip_add", text=_("Adjustment Layer")).type = 'ADJUSTMENT'
 
 
 class SEQUENCER_MT_strip(Menu):
@@ -236,13 +237,13 @@ class SEQUENCER_MT_strip(Menu):
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("transform.transform", text="Grab/Move").mode = 'TRANSLATION'
-        layout.operator("transform.transform", text="Grab/Extend from frame").mode = 'TIME_EXTEND'
+        layout.operator("transform.transform", text=_("Grab/Move")).mode = 'TRANSLATION'
+        layout.operator("transform.transform", text=_("Grab/Extend from frame")).mode = 'TIME_EXTEND'
         #  uiItemO(layout, NULL, 0, "sequencer.strip_snap"); // TODO - add this operator
         layout.separator()
 
-        layout.operator("sequencer.cut", text="Cut (hard) at frame").type = 'HARD'
-        layout.operator("sequencer.cut", text="Cut (soft) at frame").type = 'SOFT'
+        layout.operator("sequencer.cut", text=_("Cut (hard) at frame")).type = 'HARD'
+        layout.operator("sequencer.cut", text=_("Cut (soft) at frame")).type = 'SOFT'
         layout.operator("sequencer.images_separate")
         layout.operator("sequencer.offset_clear")
         layout.operator("sequencer.deinterlace_selected_movies")
@@ -296,7 +297,7 @@ class SEQUENCER_MT_strip(Menu):
         layout.operator("sequencer.mute")
         layout.operator("sequencer.unmute")
 
-        layout.operator("sequencer.mute", text="Mute Deselected Strips").unselected = True
+        layout.operator("sequencer.mute", text=_("Mute Deselected Strips")).unselected = True
 
         layout.operator("sequencer.snap")
 
@@ -344,21 +345,21 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, Panel):
         strip = act_strip(context)
 
         split = layout.split(percentage=0.3)
-        split.label(text="Name:")
+        split.label(text=_("Name:"))
         split.prop(strip, "name", text="")
 
         split = layout.split(percentage=0.3)
-        split.label(text="Type:")
+        split.label(text=_("Type:"))
         split.prop(strip, "type", text="")
 
         split = layout.split(percentage=0.3)
-        split.label(text="Blend:")
+        split.label(text=_("Blend:"))
         split.prop(strip, "blend_type", text="")
 
         row = layout.row(align=True)
         sub = row.row()
         sub.active = (not strip.mute)
-        sub.prop(strip, "blend_alpha", text="Opacity", slider=True)
+        sub.prop(strip, "blend_alpha", text=_("Opacity"), slider=True)
         row.prop(strip, "mute", toggle=True, icon='RESTRICT_VIEW_ON' if strip.mute else 'RESTRICT_VIEW_OFF', text="")
         row.prop(strip, "lock", toggle=True, icon='LOCKED' if strip.lock else 'UNLOCKED', text="")
 
@@ -371,13 +372,13 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, Panel):
 
         col = layout.column(align=True)
         row = col.row()
-        row.label(text="Final Length: %s" % bpy.utils.smpte_from_frame(strip.frame_final_duration))
+        row.label(text=_("Final Length")+": %s" % bpy.utils.smpte_from_frame(strip.frame_final_duration))
         row = col.row()
         row.active = (frame_current >= strip.frame_start and frame_current <= strip.frame_start + strip.frame_duration)
-        row.label(text="Playhead: %d" % (frame_current - strip.frame_start))
+        row.label(text=_("Playhead")+": %d" % (frame_current - strip.frame_start))
 
-        col.label(text="Frame Offset %d:%d" % (strip.frame_offset_start, strip.frame_offset_end))
-        col.label(text="Frame Still %d:%d" % (strip.frame_still_start, strip.frame_still_end))
+        col.label(text=_("Frame Offset")+" %d:%d" % (strip.frame_offset_start, strip.frame_offset_end))
+        col.label(text=_("Frame Still")+" %d:%d" % (strip.frame_still_start, strip.frame_still_end))
 
         elem = False
 
@@ -387,9 +388,9 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, Panel):
             elem = strip.elements[0]
 
         if elem and elem.orig_width > 0 and elem.orig_height > 0:
-            col.label(text="Orig Dim: %dx%d" % (elem.orig_width, elem.orig_height))
+            col.label(text=_("Orig Dim")+": %dx%d" % (elem.orig_width, elem.orig_height))
         else:
-            col.label(text="Orig Dim: None")
+            col.label(text=_("Orig Dim: None"))
 
 
 class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
@@ -429,7 +430,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
 
             col = layout.column()
             col.prop(strip, "transition_type")
-            col.label(text="Direction:")
+            col.label(text=_("Direction:"))
             col.row().prop(strip, "direction", expand=True)
 
             col = layout.column()
@@ -449,13 +450,13 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
             row.prop(strip, "use_only_boost")
 
         elif strip.type == 'SPEED':
-            layout.prop(strip, "use_default_fade", "Stretch to input strip length")
+            layout.prop(strip, "use_default_fade", _("Stretch to input strip length"))
             if not strip.use_default_fade:
                 layout.prop(strip, "use_as_speed")
                 if strip.use_as_speed:
                     layout.prop(strip, "speed_factor")
                 else:
-                    layout.prop(strip, "speed_factor", text="Frame number")
+                    layout.prop(strip, "speed_factor", text=_("Frame number"))
                     layout.prop(strip, "scale_to_length")
 
             #doesn't work currently
@@ -473,7 +474,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
 
             sub.operator("screen.animation_play", text="", icon='PAUSE' if context.screen.is_animation_playing else 'PLAY')
 
-            row.label("Cut To")
+            row.label(_("Cut To"))
             for i in range(1, strip.channel):
                 row.operator("sequencer.cut_multicam", text=str(i)).camera = i
 
@@ -481,17 +482,17 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
         if strip.type == 'SPEED':
             col.prop(strip, "multiply_speed")
         elif strip.type in {'CROSS', 'GAMMA_CROSS', 'PLUGIN', 'WIPE'}:
-                col.prop(strip, "use_default_fade", "Default fade")
+                col.prop(strip, "use_default_fade", _("Default fade"))
                 if not strip.use_default_fade:
-                    col.prop(strip, "effect_fader", text="Effect fader")
+                    col.prop(strip, "effect_fader", text=_("Effect fader"))
 
-        layout.prop(strip, "use_translation", text="Image Offset:")
+        layout.prop(strip, "use_translation", text=_("Image Offset:"))
         if strip.use_translation:
             col = layout.column(align=True)
             col.prop(strip.transform, "offset_x", text="X")
             col.prop(strip.transform, "offset_y", text="Y")
 
-        layout.prop(strip, "use_crop", text="Image Crop:")
+        layout.prop(strip, "use_crop", text=_("Image Crop:"))
         if strip.use_crop:
             col = layout.column(align=True)
             col.prop(strip.crop, "max_y")
@@ -506,7 +507,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
         col.prop(strip, "interpolation")
         col.prop(strip, "translation_unit")
         col = layout.column(align=True)
-        col.label(text="Position:")
+        col.label(text=_("Position:"))
         col.prop(strip, "translate_start_x", text="X")
         col.prop(strip, "translate_start_y", text="Y")
 
@@ -516,18 +517,18 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
         col.prop(strip, "use_uniform_scale")
         if (strip.use_uniform_scale):
             col = layout.column(align=True)
-            col.prop(strip, "scale_start_x", text="Scale")
+            col.prop(strip, "scale_start_x", text=_("Scale"))
         else:
             col = layout.column(align=True)
-            col.label(text="Scale:")
+            col.label(text=_("Scale:"))
             col.prop(strip, "scale_start_x", text="X")
             col.prop(strip, "scale_start_y", text="Y")
 
         layout.separator()
 
         col = layout.column(align=True)
-        col.label(text="Rotation:")
-        col.prop(strip, "rotation_start", text="Rotation")
+        col.label(text=_("Rotation:"))
+        col.prop(strip, "rotation_start", text=_("Rotation"))
 
 
 class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
@@ -560,7 +561,7 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
         if seq_type == 'IMAGE':
             split = layout.split(percentage=0.2)
             col = split.column()
-            col.label(text="Path:")
+            col.label(text=_("Path:"))
             col = split.column()
             col.prop(strip, "directory", text="")
 
@@ -570,7 +571,7 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
             if elem:
                 split = layout.split(percentage=0.2)
                 col = split.column()
-                col.label(text="File:")
+                col.label(text=_("File:"))
                 col = split.column()
                 col.prop(elem, "filename", text="")  # strip.elements[0] could be a fallback
 
@@ -580,22 +581,22 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
         elif seq_type == 'MOVIE':
             split = layout.split(percentage=0.2)
             col = split.column()
-            col.label(text="Path:")
+            col.label(text=_("Path:"))
             col = split.column()
             col.prop(strip, "filepath", text="")
-            col.prop(strip, "mpeg_preseek", text="MPEG Preseek")
-            col.prop(strip, "streamindex", text="Stream Index")
+            col.prop(strip, "mpeg_preseek", text=_("MPEG Preseek"))
+            col.prop(strip, "streamindex", text=_("Stream Index"))
 
         # TODO, sound???
         # end drawing filename
 
-        layout.prop(strip, "use_translation", text="Image Offset:")
+        layout.prop(strip, "use_translation", text=_("Image Offset:"))
         if strip.use_translation:
             col = layout.column(align=True)
             col.prop(strip.transform, "offset_x", text="X")
             col.prop(strip.transform, "offset_y", text="Y")
 
-        layout.prop(strip, "use_crop", text="Image Crop:")
+        layout.prop(strip, "use_crop", text=_("Image Crop:"))
         if strip.use_crop:
             col = layout.column(align=True)
             col.prop(strip.crop, "max_y")
@@ -605,14 +606,14 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
 
         if not isinstance(strip, bpy.types.EffectSequence):
             col = layout.column(align=True)
-            col.label(text="Trim Duration (hard):")
-            col.prop(strip, "animation_offset_start", text="Start")
-            col.prop(strip, "animation_offset_end", text="End")
+            col.label(text=_("Trim Duration (hard):"))
+            col.prop(strip, "animation_offset_start", text=_("Start"))
+            col.prop(strip, "animation_offset_end", text=_("End"))
 
         col = layout.column(align=True)
-        col.label(text="Trim Duration (soft):")
-        col.prop(strip, "frame_offset_start", text="Start")
-        col.prop(strip, "frame_offset_end", text="End")
+        col.label(text=_("Trim Duration (soft):"))
+        col.prop(strip, "frame_offset_start", text=_("Start"))
+        col.prop(strip, "frame_offset_end", text=_("End"))
 
 
 class SEQUENCER_PT_sound(SequencerButtonsPanel, Panel):
@@ -641,9 +642,9 @@ class SEQUENCER_PT_sound(SequencerButtonsPanel, Panel):
 
         row = layout.row()
         if strip.sound.packed_file:
-            row.operator("sound.unpack", icon='PACKAGE', text="Unpack")
+            row.operator("sound.unpack", icon='PACKAGE', text=_("Unpack"))
         else:
-            row.operator("sound.pack", icon='UGLYPACKAGE', text="Pack")
+            row.operator("sound.pack", icon='UGLYPACKAGE', text=_("Pack"))
 
         row.prop(strip.sound, "use_memory_cache")
 
@@ -654,8 +655,8 @@ class SEQUENCER_PT_sound(SequencerButtonsPanel, Panel):
 
         col = layout.column(align=True)
         col.label(text="Trim Duration:")
-        col.prop(strip, "animation_offset_start", text="Start")
-        col.prop(strip, "animation_offset_end", text="End")
+        col.prop(strip, "animation_offset_start", text=_("Start"))
+        col.prop(strip, "animation_offset_end", text=_("End"))
 
 
 class SEQUENCER_PT_scene(SequencerButtonsPanel, Panel):
@@ -683,13 +684,13 @@ class SEQUENCER_PT_scene(SequencerButtonsPanel, Panel):
         if scene:
             layout.prop(scene.render, "use_sequencer")
 
-        layout.label(text="Camera Override")
+        layout.label(text=_("Camera Override"))
         layout.template_ID(strip, "scene_camera")
 
         if scene:
             sta = scene.frame_start
             end = scene.frame_end
-            layout.label(text="Original frame range: %d-%d (%d)" % (sta, end, end - sta + 1))
+            layout.label(text=_("Original frame range")+": %d-%d (%d)" % (sta, end, end - sta + 1))
 
 
 class SEQUENCER_PT_filter(SequencerButtonsPanel, Panel):
@@ -717,22 +718,22 @@ class SEQUENCER_PT_filter(SequencerButtonsPanel, Panel):
         strip = act_strip(context)
 
         col = layout.column()
-        col.label(text="Video:")
+        col.label(text=_("Video:"))
         col.prop(strip, "strobe")
 
         row = layout.row()
-        row.label(text="Flip:")
+        row.label(text=_("Flip:"))
         row.prop(strip, "use_flip_x", text="X")
         row.prop(strip, "use_flip_y", text="Y")
 
         col = layout.column()
-        col.prop(strip, "use_reverse_frames", text="Backwards")
+        col.prop(strip, "use_reverse_frames", text=_("Backwards"))
         col.prop(strip, "use_deinterlace")
 
         col = layout.column()
-        col.label(text="Colors:")
-        col.prop(strip, "color_saturation", text="Saturation")
-        col.prop(strip, "color_multiply", text="Multiply")
+        col.label(text=_("Colors:"))
+        col.prop(strip, "color_saturation", text=_("Saturation"))
+        col.prop(strip, "color_multiply", text=_("Multiply"))
         col.prop(strip, "use_premultiply")
         col.prop(strip, "use_float")
 
@@ -743,15 +744,15 @@ class SEQUENCER_PT_filter(SequencerButtonsPanel, Panel):
             col = row.column()
             col.template_color_wheel(strip.color_balance, "lift", value_slider=False, cubic=True)
             col.row().prop(strip.color_balance, "lift")
-            col.prop(strip.color_balance, "invert_lift", text="Inverse")
+            col.prop(strip.color_balance, "invert_lift", text=_("Inverse"))
             col = row.column()
             col.template_color_wheel(strip.color_balance, "gamma", value_slider=False, lock_luminosity=True, cubic=True)
             col.row().prop(strip.color_balance, "gamma")
-            col.prop(strip.color_balance, "invert_gamma", text="Inverse")
+            col.prop(strip.color_balance, "invert_gamma", text=_("Inverse"))
             col = row.column()
             col.template_color_wheel(strip.color_balance, "gain", value_slider=False, lock_luminosity=True, cubic=True)
             col.row().prop(strip.color_balance, "gain")
-            col.prop(strip.color_balance, "invert_gain", text="Inverse")
+            col.prop(strip.color_balance, "invert_gain", text=_("Inverse"))
 
 
 class SEQUENCER_PT_proxy(SequencerButtonsPanel, Panel):
@@ -794,18 +795,18 @@ class SEQUENCER_PT_proxy(SequencerButtonsPanel, Panel):
             row.prop(strip.proxy, "build_100")
 
             col = layout.column()
-            col.label(text="Build JPEG quality")
+            col.label(text=_("Build JPEG quality"))
             col.prop(strip.proxy, "quality")
 
             if strip.type == "MOVIE":
                 col = layout.column()
-                col.label(text="Use timecode index:")
+                col.label(text=_("Use timecode index:"))
 
                 col.prop(strip.proxy, "timecode")
 
 
 class SEQUENCER_PT_preview(SequencerButtonsPanel_Output, Panel):
-    bl_label = "Scene Preview/Render"
+    bl_label = _("Scene Preview/Render")
     bl_space_type = 'SEQUENCE_EDITOR'
     bl_region_type = 'UI'
 
@@ -815,7 +816,7 @@ class SEQUENCER_PT_preview(SequencerButtonsPanel_Output, Panel):
 
         col = layout.column()
         col.active = False  # Currently only opengl preview works!
-        col.prop(render, "use_sequencer_gl_preview", text="Open GL Preview")
+        col.prop(render, "use_sequencer_gl_preview", text=_("Open GL Preview"))
         col = layout.column()
         #col.active = render.use_sequencer_gl_preview
         col.prop(render, "sequencer_gl_preview", text="")
diff --git a/release/scripts/startup/bl_ui/space_text.py b/release/scripts/startup/bl_ui/space_text.py
index 12e07c19ca1..cd72d42857b 100644
--- a/release/scripts/startup/bl_ui/space_text.py
+++ b/release/scripts/startup/bl_ui/space_text.py
@@ -19,6 +19,7 @@
 # <pep8-80 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
+from blf import gettext as _
 
 
 class TEXT_HT_header(Header):
@@ -66,13 +67,13 @@ class TEXT_HT_header(Header):
             row = layout.row()
             if text.filepath:
                 if text.is_dirty:
-                    row.label(text="File: *%r (unsaved)" % text.filepath)
+                    row.label(text=_("File")+": *%r " % text.filepath+_("(unsaved)"))
                 else:
-                    row.label(text="File: %r" % text.filepath)
+                    row.label(text=_("File")+": %r" % text.filepath)
             else:
-                row.label(text="Text: External"
+                row.label(text=_("Text: External")
                           if text.library
-                          else "Text: Internal")
+                          else _("Text: Internal"))
 
 
 class TEXT_PT_properties(Panel):
@@ -136,8 +137,8 @@ class TEXT_PT_find(Panel):
         # settings
         layout.prop(st, "use_match_case")
         row = layout.row()
-        row.prop(st, "use_find_wrap", text="Wrap")
-        row.prop(st, "use_find_all", text="All")
+        row.prop(st, "use_find_wrap", text=_("Wrap"))
+        row.prop(st, "use_find_all", text=_("All"))
 
 
 class TEXT_MT_view(Menu):
@@ -156,10 +157,10 @@ class TEXT_MT_view(Menu):
         layout.separator()
 
         layout.operator("text.move",
-                        text="Top of File",
+                        text=_("Top of File"),
                         ).type = 'FILE_TOP'
         layout.operator("text.move",
-                        text="Bottom of File",
+                        text=_("Bottom of File"),
                         ).type = 'FILE_BOTTOM'
 
 
@@ -248,10 +249,10 @@ class TEXT_MT_edit_to3d(Menu):
         layout = self.layout
 
         layout.operator("text.to_3d_object",
-                        text="One Object",
+                        text=_("One Object"),
                         ).split_lines = False
         layout.operator("text.to_3d_object",
-                        text="One Object Per Line",
+                        text=_("One Object Per Line"),
                         ).split_lines = True
 
 
@@ -282,7 +283,7 @@ class TEXT_MT_edit(Menu):
         layout.separator()
 
         layout.operator("text.jump")
-        layout.operator("text.properties", text="Find...")
+        layout.operator("text.properties", text=_("Find..."))
 
         layout.separator()
 
diff --git a/release/scripts/startup/bl_ui/space_time.py b/release/scripts/startup/bl_ui/space_time.py
index db009fe43c2..d654c1e4d8b 100644
--- a/release/scripts/startup/bl_ui/space_time.py
+++ b/release/scripts/startup/bl_ui/space_time.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu
+from blf import gettext as _
 
 
 class TIME_HT_header(Header):
@@ -43,11 +44,11 @@ class TIME_HT_header(Header):
 
         row = layout.row(align=True)
         if not scene.use_preview_range:
-            row.prop(scene, "frame_start", text="Start")
-            row.prop(scene, "frame_end", text="End")
+            row.prop(scene, "frame_start", text=_("Start"))
+            row.prop(scene, "frame_end", text=_("End"))
         else:
-            row.prop(scene, "frame_preview_start", text="Start")
-            row.prop(scene, "frame_preview_end", text="End")
+            row.prop(scene, "frame_preview_start", text=_("Start"))
+            row.prop(scene, "frame_preview_end", text=_("End"))
 
         layout.prop(scene, "frame_current", text="")
 
@@ -142,14 +143,14 @@ class TIME_MT_frame(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("marker.add", text="Add Marker")
-        layout.operator("marker.duplicate", text="Duplicate Marker")
-        layout.operator("marker.delete", text="Delete Marker")
+        layout.operator("marker.add", text=_("Add Marker"))
+        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
+        layout.operator("marker.delete", text=_("Delete Marker"))
 
         layout.separator()
 
-        layout.operator("marker.rename", text="Rename Marker")
-        layout.operator("marker.move", text="Grab/Move Marker")
+        layout.operator("marker.rename", text=_("Rename Marker"))
+        layout.operator("marker.move", text=_("Grab/Move Marker"))
 
         layout.separator()
 
@@ -181,8 +182,8 @@ class TIME_MT_playback(Menu):
 
         layout.separator()
 
-        layout.prop(scene, "use_frame_drop", text="Frame Dropping")
-        layout.prop(scene, "use_audio_sync", text="AV-sync", icon='SPEAKER')
+        layout.prop(scene, "use_frame_drop", text=_("Frame Dropping"))
+        layout.prop(scene, "use_audio_sync", text=_("AV-sync"), icon='SPEAKER')
         layout.prop(scene, "use_audio")
         layout.prop(scene, "use_audio_scrub")
 
diff --git a/release/scripts/startup/bl_ui/space_userpref.py b/release/scripts/startup/bl_ui/space_userpref.py
index 3e3ca913e88..d0e7ae5e609 100644
--- a/release/scripts/startup/bl_ui/space_userpref.py
+++ b/release/scripts/startup/bl_ui/space_userpref.py
@@ -23,6 +23,7 @@ import os
 import addon_utils
 
 from bpy.props import StringProperty, BoolProperty, EnumProperty
+from blf import gettext as _
 
 
 def ui_items_general(col, context):
@@ -65,10 +66,10 @@ def opengl_lamp_buttons(column, lamp):
     col = split.column()
     col.active = lamp.use
     row = col.row()
-    row.label(text="Diffuse:")
+    row.label(text=_("Diffuse:"))
     row.prop(lamp, "diffuse_color", text="")
     row = col.row()
-    row.label(text="Specular:")
+    row.label(text=_("Specular:"))
     row.prop(lamp, "specular_color", text="")
 
     col = split.column()
@@ -86,7 +87,7 @@ class USERPREF_HT_header(Header):
         userpref = context.user_preferences
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("wm.save_homefile", text="Save As Default")
+        layout.operator("wm.save_homefile", text=_("Save As Default"))
 
         layout.operator_context = 'INVOKE_DEFAULT'
 
@@ -127,7 +128,7 @@ class USERPREF_MT_appconfigs(Menu):
     preset_operator = "wm.appconfig_activate"
 
     def draw(self, context):
-        self.layout.operator("wm.appconfig_default", text="Blender (default)")
+        self.layout.operator("wm.appconfig_default", text=_("Blender (default)"))
 
         # now draw the presets
         Menu.draw_preset(self, context)
@@ -142,12 +143,12 @@ class USERPREF_MT_splash(Menu):
         row = split.row()
         row.label("")
         row = split.row()
-        row.label("Interaction:")
+        row.label(_("Interaction:"))
         # XXX, no redraws
         # text = bpy.path.display_name(context.window_manager.keyconfigs.active.name)
         # if not text:
         #     text = "Blender (default)"
-        row.menu("USERPREF_MT_appconfigs", text="Preset")
+        row.menu("USERPREF_MT_appconfigs", text=_("Preset"))
 
 
 class USERPREF_PT_interface(Panel):
@@ -170,13 +171,13 @@ class USERPREF_PT_interface(Panel):
         row = layout.row()
 
         col = row.column()
-        col.label(text="Display:")
+        col.label(text=_("Display:"))
         col.prop(view, "show_tooltips")
         col.prop(view, "show_tooltips_python")
-        col.prop(view, "show_object_info", text="Object Info")
+        col.prop(view, "show_object_info", text=_("Object Info"))
         col.prop(view, "show_large_cursors")
-        col.prop(view, "show_view_name", text="View Name")
-        col.prop(view, "show_playback_fps", text="Playback FPS")
+        col.prop(view, "show_view_name", text=_("View Name"))
+        col.prop(view, "show_playback_fps", text=_("Playback FPS"))
         col.prop(view, "use_global_scene")
         col.prop(view, "object_origin_size")
 
@@ -184,18 +185,18 @@ class USERPREF_PT_interface(Panel):
         col.separator()
         col.separator()
 
-        col.prop(view, "show_mini_axis", text="Display Mini Axis")
+        col.prop(view, "show_mini_axis", text=_("Display Mini Axis"))
         sub = col.column()
         sub.active = view.show_mini_axis
-        sub.prop(view, "mini_axis_size", text="Size")
-        sub.prop(view, "mini_axis_brightness", text="Brightness")
+        sub.prop(view, "mini_axis_size", text=_("Size"))
+        sub.prop(view, "mini_axis_brightness", text=_("Brightness"))
 
         col.separator()
         row.separator()
         row.separator()
 
         col = row.column()
-        col.label(text="View Manipulation:")
+        col.label(text=_("View Manipulation:"))
         col.prop(view, "use_mouse_auto_depth")
         col.prop(view, "use_zoom_to_mouse")
         col.prop(view, "use_rotate_around_active")
@@ -211,8 +212,8 @@ class USERPREF_PT_interface(Panel):
         col.separator()
         col.separator()
 
-        col.label(text="2D Viewports:")
-        col.prop(view, "view2d_grid_spacing_min", text="Minimum Grid Spacing")
+        col.label(text=_("2D Viewports:"))
+        col.prop(view, "view2d_grid_spacing_min", text=_("Minimum Grid Spacing"))
         col.prop(view, "timecode_style")
 
         row.separator()
@@ -228,19 +229,19 @@ class USERPREF_PT_interface(Panel):
         col.prop(view, "show_manipulator")
         sub = col.column()
         sub.active = view.show_manipulator
-        sub.prop(view, "manipulator_size", text="Size")
-        sub.prop(view, "manipulator_handle_size", text="Handle Size")
-        sub.prop(view, "manipulator_hotspot", text="Hotspot")
+        sub.prop(view, "manipulator_size", text=_("Size"))
+        sub.prop(view, "manipulator_handle_size", text=_("Handle Size"))
+        sub.prop(view, "manipulator_hotspot", text=_("Hotspot"))
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="Menus:")
+        col.label(text=_("Menus:"))
         col.prop(view, "use_mouse_over_open")
-        col.label(text="Menu Open Delay:")
-        col.prop(view, "open_toplevel_delay", text="Top Level")
-        col.prop(view, "open_sublevel_delay", text="Sub Level")
+        col.label(text=_("Menu Open Delay:"))
+        col.prop(view, "open_toplevel_delay", text=_("Top Level"))
+        col.prop(view, "open_sublevel_delay", text=_("Sub Level"))
 
         col.separator()
 
@@ -267,97 +268,97 @@ class USERPREF_PT_edit(Panel):
         row = layout.row()
 
         col = row.column()
-        col.label(text="Link Materials To:")
+        col.label(text=_("Link Materials To:"))
         col.prop(edit, "material_link", text="")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="New Objects:")
+        col.label(text=_("New Objects:"))
         col.prop(edit, "use_enter_edit_mode")
-        col.label(text="Align To:")
+        col.label(text=_("Align To:"))
         col.prop(edit, "object_align", text="")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="Undo:")
+        col.label(text=_("Undo:"))
         col.prop(edit, "use_global_undo")
-        col.prop(edit, "undo_steps", text="Steps")
-        col.prop(edit, "undo_memory_limit", text="Memory Limit")
+        col.prop(edit, "undo_steps", text=_("Steps"))
+        col.prop(edit, "undo_memory_limit", text=_("Memory Limit"))
 
         row.separator()
         row.separator()
 
         col = row.column()
-        col.label(text="Grease Pencil:")
-        col.prop(edit, "grease_pencil_manhattan_distance", text="Manhattan Distance")
-        col.prop(edit, "grease_pencil_euclidean_distance", text="Euclidean Distance")
+        col.label(text=_("Grease Pencil:"))
+        col.prop(edit, "grease_pencil_manhattan_distance", text=_("Manhattan Distance"))
+        col.prop(edit, "grease_pencil_euclidean_distance", text=_("Euclidean Distance"))
         #col.prop(edit, "use_grease_pencil_simplify_stroke", text="Simplify Stroke")
-        col.prop(edit, "grease_pencil_eraser_radius", text="Eraser Radius")
-        col.prop(edit, "use_grease_pencil_smooth_stroke", text="Smooth Stroke")
+        col.prop(edit, "grease_pencil_eraser_radius", text=_("Eraser Radius"))
+        col.prop(edit, "use_grease_pencil_smooth_stroke", text=_("Smooth Stroke"))
         col.separator()
         col.separator()
         col.separator()
-        col.label(text="Playback:")
+        col.label(text=_("Playback:"))
         col.prop(edit, "use_negative_frames")
 
         row.separator()
         row.separator()
 
         col = row.column()
-        col.label(text="Keyframing:")
+        col.label(text=_("Keyframing:"))
         col.prop(edit, "use_visual_keying")
-        col.prop(edit, "use_keyframe_insert_needed", text="Only Insert Needed")
+        col.prop(edit, "use_keyframe_insert_needed", text=_("Only Insert Needed"))
 
         col.separator()
 
-        col.prop(edit, "use_auto_keying", text="Auto Keyframing:")
+        col.prop(edit, "use_auto_keying", text=_("Auto Keyframing:"))
 
         sub = col.column()
 
         # sub.active = edit.use_keyframe_insert_auto # incorrect, timeline can enable
-        sub.prop(edit, "use_keyframe_insert_available", text="Only Insert Available")
+        sub.prop(edit, "use_keyframe_insert_available", text=_("Only Insert Available"))
 
         col.separator()
 
-        col.label(text="New F-Curve Defaults:")
-        col.prop(edit, "keyframe_new_interpolation_type", text="Interpolation")
-        col.prop(edit, "keyframe_new_handle_type", text="Handles")
-        col.prop(edit, "use_insertkey_xyz_to_rgb", text="XYZ to RGB")
+        col.label(text=_("New F-Curve Defaults:"))
+        col.prop(edit, "keyframe_new_interpolation_type", text=_("Interpolation"))
+        col.prop(edit, "keyframe_new_handle_type", text=_("Handles"))
+        col.prop(edit, "use_insertkey_xyz_to_rgb", text=_("XYZ to RGB"))
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="Transform:")
+        col.label(text=_("Transform:"))
         col.prop(edit, "use_drag_immediately")
 
         row.separator()
         row.separator()
 
         col = row.column()
-        col.prop(edit, "sculpt_paint_overlay_color", text="Sculpt Overlay Color")
+        col.prop(edit, "sculpt_paint_overlay_color", text=_("Sculpt Overlay Color"))
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="Duplicate Data:")
-        col.prop(edit, "use_duplicate_mesh", text="Mesh")
-        col.prop(edit, "use_duplicate_surface", text="Surface")
-        col.prop(edit, "use_duplicate_curve", text="Curve")
-        col.prop(edit, "use_duplicate_text", text="Text")
-        col.prop(edit, "use_duplicate_metaball", text="Metaball")
-        col.prop(edit, "use_duplicate_armature", text="Armature")
-        col.prop(edit, "use_duplicate_lamp", text="Lamp")
-        col.prop(edit, "use_duplicate_material", text="Material")
-        col.prop(edit, "use_duplicate_texture", text="Texture")
-        #col.prop(edit, "use_duplicate_fcurve", text="F-Curve")
-        col.prop(edit, "use_duplicate_action", text="Action")
-        col.prop(edit, "use_duplicate_particle", text="Particle")
+        col.label(text=_("Duplicate Data:"))
+        col.prop(edit, "use_duplicate_mesh", text=_("Mesh"))
+        col.prop(edit, "use_duplicate_surface", text=_("Surface"))
+        col.prop(edit, "use_duplicate_curve", text=_("Curve"))
+        col.prop(edit, "use_duplicate_text", text=_("Text"))
+        col.prop(edit, "use_duplicate_metaball", text=_("Metaball"))
+        col.prop(edit, "use_duplicate_armature", text=_("Armature"))
+        col.prop(edit, "use_duplicate_lamp", text=_("Lamp"))
+        col.prop(edit, "use_duplicate_material", text=_("Material"))
+        col.prop(edit, "use_duplicate_texture", text=_("Texture"))
+        #col.prop(edit, "use_duplicate_fcurve", text=_("F-Curve"))
+        col.prop(edit, "use_duplicate_action", text=_("Action"))
+        col.prop(edit, "use_duplicate_particle", text=_("Particle"))
 
 
 class USERPREF_PT_system(Panel):
@@ -384,11 +385,11 @@ class USERPREF_PT_system(Panel):
         colsplit = column.split(percentage=0.85)
 
         col = colsplit.column()
-        col.label(text="General:")
+        col.label(text=_("General:"))
         col.prop(system, "dpi")
         col.prop(system, "frame_server_port")
-        col.prop(system, "scrollback", text="Console Scrollback")
-        col.prop(system, "author", text="Author")
+        col.prop(system, "scrollback", text=_("Console Scrollback"))
+        col.prop(system, "author", text=_("Author"))
         col.prop(system, "use_scripts_auto_execute")
         col.prop(system, "use_tabs_as_spaces")
 
@@ -396,80 +397,66 @@ class USERPREF_PT_system(Panel):
         col.separator()
         col.separator()
 
-        col.label(text="Sound:")
+        col.label(text=_("Sound:"))
         col.row().prop(system, "audio_device", expand=True)
         sub = col.column()
         sub.active = system.audio_device != 'NONE'
         #sub.prop(system, "use_preview_images")
-        sub.prop(system, "audio_channels", text="Channels")
-        sub.prop(system, "audio_mixing_buffer", text="Mixing Buffer")
-        sub.prop(system, "audio_sample_rate", text="Sample Rate")
-        sub.prop(system, "audio_sample_format", text="Sample Format")
+        sub.prop(system, "audio_channels", text=_("Channels"))
+        sub.prop(system, "audio_mixing_buffer", text=_("Mixing Buffer"))
+        sub.prop(system, "audio_sample_rate", text=_("Sample Rate"))
+        sub.prop(system, "audio_sample_format", text=_("Sample Format"))
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="Screencast:")
+        col.label(text=_("Screencast:"))
         col.prop(system, "screencast_fps")
         col.prop(system, "screencast_wait_time")
         col.separator()
         col.separator()
         col.separator()
 
-        #column = split.column()
-        #colsplit = column.split(percentage=0.85)
-
-        # No translation in 2.5 yet
-        #col.prop(system, "language")
-        #col.label(text="Translate:")
-        #col.prop(system, "use_translate_tooltips", text="Tooltips")
-        #col.prop(system, "use_translate_buttons", text="Labels")
-        #col.prop(system, "use_translate_toolbox", text="Toolbox")
-
-        #col.separator()
-
-        #col.prop(system, "use_textured_fonts")
-
         # 2. Column
         column = split.column()
         colsplit = column.split(percentage=0.85)
 
         col = colsplit.column()
-        col.label(text="OpenGL:")
+        col.label(text=_("OpenGL:"))
         col.prop(system, "gl_clip_alpha", slider=True)
         col.prop(system, "use_mipmaps")
-        col.label(text="Anisotropic Filtering")
+        col.label(text=_("Anisotropic Filtering"))
         col.prop(system, "anisotropic_filter", text="")
         col.prop(system, "use_vertex_buffer_objects")
         #Anti-aliasing is disabled as it breaks broder/lasso select
         #col.prop(system, "use_antialiasing")
-        col.label(text="Window Draw Method:")
+        col.label(text=_("Window Draw Method:"))
         col.prop(system, "window_draw_method", text="")
-        col.label(text="Text Draw Options:")
+        col.label(text=_("Text Draw Options:"))
         col.prop(system, "use_text_antialiasing")
-        col.label(text="Textures:")
-        col.prop(system, "gl_texture_limit", text="Limit Size")
-        col.prop(system, "texture_time_out", text="Time Out")
-        col.prop(system, "texture_collection_rate", text="Collection Rate")
+        col.label(text=_("Textures:"))
+        col.prop(system, "gl_texture_limit", text=_("Limit Size"))
+        col.prop(system, "texture_time_out", text=_("Time Out"))
+        col.prop(system, "texture_collection_rate", text=_("Collection Rate"))
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text="Sequencer:")
+        col.label(text=_("Sequencer:"))
         col.prop(system, "prefetch_frames")
         col.prop(system, "memory_cache_limit")
 
         # 3. Column
         column = split.column()
 
-        column.label(text="Solid OpenGL lights:")
+        column.label(text=_("Solid OpenGL lights:"))
 
         split = column.split(percentage=0.1)
         split.label()
-        split.label(text="Colors:")
-        split.label(text="Direction:")
+        split.label(text=_("Colors:"))
+        split.label(text=_("Direction:"))
 
         lamp = system.solid_lights[0]
         opengl_lamp_buttons(column, lamp)
@@ -481,21 +468,27 @@ class USERPREF_PT_system(Panel):
         opengl_lamp_buttons(column, lamp)
 
         column.separator()
-        column.separator()
-        column.separator()
 
-        column.label(text="Color Picker Type:")
+        column.label(text=_("Color Picker Type:"))
         column.row().prop(system, "color_picker_type", text="")
 
         column.separator()
-        column.separator()
-        column.separator()
 
-        column.prop(system, "use_weight_color_range", text="Custom Weight Paint Range")
+        column.prop(system, "use_weight_color_range", text=_("Custom Weight Paint Range"))
         sub = column.column()
         sub.active = system.use_weight_color_range
         sub.template_color_ramp(system, "weight_color_range", expand=True)
 
+        column.separator()
+
+        column.prop(system, "use_international_fonts")
+        if system.use_international_fonts:
+            column.prop(system, "language")
+            row = column.row()
+            row.label(text="Translate:")
+            row.prop(system, "use_translate_interface", text="Interface")
+            row.prop(system, "use_translate_tooltips", text="Tooltips")
+
 
 class USERPREF_PT_theme(Panel):
     bl_space_type = 'USER_PREFERENCES'
@@ -557,71 +550,71 @@ class USERPREF_PT_theme(Panel):
             col = split.column()
 
             ui = theme.user_interface.wcol_regular
-            col.label(text="Regular:")
+            col.label(text=_("Regular:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_tool
-            col.label(text="Tool:")
+            col.label(text=_("Tool:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_radio
-            col.label(text="Radio Buttons:")
+            col.label(text=_("Radio Buttons:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_text
-            col.label(text="Text:")
+            col.label(text=_("Text:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_option
-            col.label(text="Option:")
+            col.label(text=_("Option:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_toggle
-            col.label(text="Toggle:")
+            col.label(text=_("Toggle:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_num
-            col.label(text="Number Field:")
+            col.label(text=_("Number Field:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_numslider
-            col.label(text="Value Slider:")
+            col.label(text=_("Value Slider:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_box
-            col.label(text="Box:")
+            col.label(text=_("Box:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_menu
-            col.label(text="Menu:")
+            col.label(text=_("Menu:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_pulldown
-            col.label(text="Pulldown:")
+            col.label(text=_("Pulldown:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_menu_back
-            col.label(text="Menu Back:")
+            col.label(text=_("Menu Back:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_menu_item
-            col.label(text="Menu Item:")
+            col.label(text=_("Menu Item:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_scroll
-            col.label(text="Scroll Bar:")
+            col.label(text=_("Scroll Bar:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_progress
-            col.label(text="Progress Bar:")
+            col.label(text=_("Progress Bar:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_list_item
-            col.label(text="List Item:")
+            col.label(text=_("List Item:"))
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_state
-            col.label(text="State:")
+            col.label(text=_("State:"))
 
             row = col.row()
 
@@ -657,7 +650,7 @@ class USERPREF_PT_theme(Panel):
             col = split.column()
 
             for i, ui in enumerate(theme.bone_color_sets):
-                col.label(text="Color Set %d:" % (i + 1))  # i starts from 0
+                col.label(text=_("Color Set")+" %d:" % (i + 1))  # i starts from 0
 
                 row = col.row()
 
@@ -700,22 +693,22 @@ class USERPREF_PT_file(Panel):
         split = layout.split(percentage=0.7)
 
         col = split.column()
-        col.label(text="File Paths:")
+        col.label(text=_("File Paths:"))
 
         colsplit = col.split(percentage=0.95)
         col1 = colsplit.split(percentage=0.3)
 
         sub = col1.column()
-        sub.label(text="Fonts:")
-        sub.label(text="Textures:")
-        sub.label(text="Texture Plugins:")
-        sub.label(text="Sequence Plugins:")
-        sub.label(text="Render Output:")
-        sub.label(text="Scripts:")
-        sub.label(text="Sounds:")
-        sub.label(text="Temp:")
-        sub.label(text="Image Editor:")
-        sub.label(text="Animation Player:")
+        sub.label(text=_("Fonts:"))
+        sub.label(text=_("Textures:"))
+        sub.label(text=_("Texture Plugins:"))
+        sub.label(text=_("Sequence Plugins:"))
+        sub.label(text=_("Render Output:"))
+        sub.label(text=_("Scripts:"))
+        sub.label(text=_("Sounds:"))
+        sub.label(text=_("Temp:"))
+        sub.label(text=_("Image Editor:"))
+        sub.label(text=_("Animation Player:"))
 
         sub = col1.column()
         sub.prop(paths, "font_directory", text="")
@@ -732,7 +725,7 @@ class USERPREF_PT_file(Panel):
         subsplit.prop(paths, "animation_player", text="")
 
         col = split.column()
-        col.label(text="Save & Load:")
+        col.label(text=_("Save & Load:"))
         col.prop(paths, "use_relative_paths")
         col.prop(paths, "use_file_compression")
         col.prop(paths, "use_load_ui")
@@ -747,11 +740,11 @@ class USERPREF_PT_file(Panel):
         col.prop(paths, "save_version")
         col.prop(paths, "recent_files")
         col.prop(paths, "use_save_preview_images")
-        col.label(text="Auto Save:")
+        col.label(text=_("Auto Save:"))
         col.prop(paths, "use_auto_save_temporary_files")
         sub = col.column()
         sub.active = paths.use_auto_save_temporary_files
-        sub.prop(paths, "auto_save_time", text="Timer (mins)")
+        sub.prop(paths, "auto_save_time", text=_("Timer (mins)"))
 
 from bl_ui.space_userpref_keymap import InputKeyMapPanel
 
@@ -807,7 +800,7 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
         col = row.column()
 
         sub = col.column()
-        sub.label(text="Presets:")
+        sub.label(text=_("Presets:"))
         subrow = sub.row(align=True)
 
         subrow.menu("USERPREF_MT_interaction_presets", text=bpy.types.USERPREF_MT_interaction_presets.bl_label)
@@ -815,19 +808,19 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
         subrow.operator("wm.interaction_preset_add", text="", icon='ZOOMOUT').remove_active = True
         sub.separator()
 
-        sub.label(text="Mouse:")
+        sub.label(text=_("Mouse:"))
         sub1 = sub.column()
         sub1.active = (inputs.select_mouse == 'RIGHT')
         sub1.prop(inputs, "use_mouse_emulate_3_button")
         sub.prop(inputs, "use_mouse_continuous")
         sub.prop(inputs, "drag_threshold")
 
-        sub.label(text="Select With:")
+        sub.label(text=_("Select With:"))
         sub.row().prop(inputs, "select_mouse", expand=True)
 
         sub = col.column()
-        sub.label(text="Double Click:")
-        sub.prop(inputs, "mouse_double_click_time", text="Speed")
+        sub.label(text=_("Double Click:"))
+        sub.prop(inputs, "mouse_double_click_time", text=_("Speed"))
 
         sub.separator()
 
@@ -835,10 +828,10 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
 
         sub.separator()
 
-        sub.label(text="Orbit Style:")
+        sub.label(text=_("Orbit Style:"))
         sub.row().prop(inputs, "view_rotate_method", expand=True)
 
-        sub.label(text="Zoom Style:")
+        sub.label(text=_("Zoom Style:"))
         sub.row().prop(inputs, "view_zoom_method", text="")
         if inputs.view_zoom_method in {'DOLLY', 'CONTINUE'}:
             sub.row().prop(inputs, "view_zoom_axis", expand=True)
@@ -849,8 +842,8 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
         #col.separator()
 
         sub = col.column()
-        sub.label(text="Mouse Wheel:")
-        sub.prop(inputs, "invert_zoom_wheel", text="Invert Wheel Zoom Direction")
+        sub.label(text=_("Mouse Wheel:"))
+        sub.prop(inputs, "invert_zoom_wheel", text=_("Invert Wheel Zoom Direction"))
         #sub.prop(view, "wheel_scroll_lines", text="Scroll Lines")
 
         col.separator()
@@ -888,9 +881,9 @@ class USERPREF_MT_addons_dev_guides(Menu):
     # menu to open webpages with addons development guides
     def draw(self, context):
         layout = self.layout
-        layout.operator('wm.url_open', text='API Concepts', icon='URL').url = 'http://wiki.blender.org/index.php/Dev:2.5/Py/API/Intro'
-        layout.operator('wm.url_open', text='Addon Guidelines', icon='URL').url = 'http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Guidelines/Addons'
-        layout.operator('wm.url_open', text='How to share your addon', icon='URL').url = 'http://wiki.blender.org/index.php/Dev:Py/Sharing'
+        layout.operator('wm.url_open', text=_('API Concepts'), icon='URL').url = 'http://wiki.blender.org/index.php/Dev:2.5/Py/API/Intro'
+        layout.operator('wm.url_open', text=_('Addon Guidelines'), icon='URL').url = 'http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Guidelines/Addons'
+        layout.operator('wm.url_open', text=_('How to share your addon'), icon='URL').url = 'http://wiki.blender.org/index.php/Dev:Py/Sharing'
 
 
 class USERPREF_PT_addons(Panel):
@@ -945,10 +938,10 @@ class USERPREF_PT_addons(Panel):
         split = layout.split(percentage=0.2)
         col = split.column()
         col.prop(context.window_manager, "addon_search", text="", icon='VIEWZOOM')
-        col.label(text="Categories")
+        col.label(text=_("Categories"))
         col.prop(context.window_manager, "addon_filter", expand=True)
 
-        col.label(text="Supported Level")
+        col.label(text=_("Supported Level"))
         col.prop(context.window_manager, "addon_support", expand=True)
 
         col = split.column()
@@ -1025,23 +1018,23 @@ class USERPREF_PT_addons(Panel):
                 if info["show_expanded"]:
                     if info["description"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text='Description:')
+                        split.label(text=_('Description:'))
                         split.label(text=info["description"])
                     if info["location"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text='Location:')
+                        split.label(text=_('Location:'))
                         split.label(text=info["location"])
                     if info["author"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text='Author:')
+                        split.label(text=_('Author:'))
                         split.label(text=info["author"])
                     if info["version"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text='Version:')
+                        split.label(text=_('Version:'))
                         split.label(text='.'.join(str(x) for x in info["version"]))
                     if info["warning"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text="Warning:")
+                        split.label(text=_("Warning:"))
                         split.label(text='  ' + info["warning"], icon='ERROR')
 
                     user_addon = USERPREF_PT_addons.is_user_addon(mod, user_addon_paths)
@@ -1049,13 +1042,13 @@ class USERPREF_PT_addons(Panel):
 
                     if tot_row:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text="Internet:")
+                        split.label(text=_("Internet:"))
                         if info["wiki_url"]:
-                            split.operator("wm.url_open", text="Link to the Wiki", icon='HELP').url = info["wiki_url"]
+                            split.operator("wm.url_open", text=_("Link to the Wiki"), icon='HELP').url = info["wiki_url"]
                         if info["tracker_url"]:
-                            split.operator("wm.url_open", text="Report a Bug", icon='URL').url = info["tracker_url"]
+                            split.operator("wm.url_open", text=_("Report a Bug"), icon='URL').url = info["tracker_url"]
                         if user_addon:
-                            split.operator("wm.addon_remove", text="Remove", icon='CANCEL').module = mod.__name__
+                            split.operator("wm.addon_remove", text=_("Remove"), icon='CANCEL').module = mod.__name__
 
                         for i in range(4 - tot_row):
                             split.separator()
@@ -1067,7 +1060,7 @@ class USERPREF_PT_addons(Panel):
 
         if missing_modules and filter in {"All", "Enabled"}:
             col.column().separator()
-            col.column().label(text="Missing script files")
+            col.column().label(text=_("Missing script files"))
 
             module_names = {mod.__name__ for mod, info in addons}
             for module_name in sorted(missing_modules):
diff --git a/release/scripts/startup/bl_ui/space_userpref_keymap.py b/release/scripts/startup/bl_ui/space_userpref_keymap.py
index 9ed1591cbf3..f8d77a1604b 100644
--- a/release/scripts/startup/bl_ui/space_userpref_keymap.py
+++ b/release/scripts/startup/bl_ui/space_userpref_keymap.py
@@ -20,6 +20,7 @@
 import bpy
 from bpy.types import Menu, Operator, OperatorProperties
 import os
+from blf import gettext as _
 
 
 KM_HIERARCHY = [
@@ -131,7 +132,7 @@ class USERPREF_MT_keyconfigs(Menu):
     preset_operator = "wm.keyconfig_activate"
 
     def draw(self, context):
-        props = self.layout.operator("wm.context_set_value", text="Blender (default)")
+        props = self.layout.operator("wm.context_set_value", text=_("Blender (default)"))
         props.data_path = "window_manager.keyconfigs.active"
         props.value = "context.window_manager.keyconfigs.default"
 
@@ -182,7 +183,7 @@ class InputKeyMapPanel:
 
         row = col.row()
         row.prop(km, "show_expanded_children", text="", emboss=False)
-        row.label(text=km.name)
+        row.label(text=_(km.name))
 
         row.label()
         row.label()
@@ -190,7 +191,7 @@ class InputKeyMapPanel:
         if km.is_modal:
             row.label(text="", icon='LINKED')
         if km.is_user_modified:
-            row.operator("wm.keymap_restore", text="Restore")
+            row.operator("wm.keymap_restore", text=_("Restore"))
         else:
             row.label()
 
@@ -201,7 +202,7 @@ class InputKeyMapPanel:
                 subcol = self.indented_layout(col, level + 1)
                 subrow = subcol.row()
                 subrow.prop(km, "show_expanded_items", text="", emboss=False)
-                subrow.label(text="%s (Global)" % km.name)
+                subrow.label(text="%s " % _(km.name) + _("(Global)") )
             else:
                 km.show_expanded_items = True
 
@@ -213,7 +214,7 @@ class InputKeyMapPanel:
                 # "Add New" at end of keymap item list
                 col = self.indented_layout(col, level + 1)
                 subcol = col.split(percentage=0.2).column()
-                subcol.operator("wm.keyitem_add", text="Add New", icon='ZOOMIN')
+                subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
 
             col.separator()
 
@@ -261,7 +262,7 @@ class InputKeyMapPanel:
         if km.is_modal:
             row.prop(kmi, "propvalue", text="")
         else:
-            row.label(text=kmi.name)
+            row.label(text=_(kmi.name))
 
         row = split.row()
         row.prop(kmi, "map_type", text="")
@@ -350,7 +351,7 @@ class InputKeyMapPanel:
                 row.label()
 
                 if km.is_user_modified:
-                    row.operator("wm.keymap_restore", text="Restore")
+                    row.operator("wm.keymap_restore", text=_("Restore"))
                 else:
                     row.label()
 
@@ -360,7 +361,7 @@ class InputKeyMapPanel:
                 # "Add New" at end of keymap item list
                 col = self.indented_layout(layout, 1)
                 subcol = col.split(percentage=0.2).column()
-                subcol.operator("wm.keyitem_add", text="Add New", icon='ZOOMIN')
+                subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
 
     def draw_hierarchy(self, display_keymaps, layout):
         for entry in KM_HIERARCHY:
@@ -381,7 +382,7 @@ class InputKeyMapPanel:
         #row.prop_search(wm.keyconfigs, "active", wm, "keyconfigs", text="Key Config:")
         text = bpy.path.display_name(context.window_manager.keyconfigs.active.name)
         if not text:
-            text = "Blender (default)"
+            text = _("Blender (default)")
         row.menu("USERPREF_MT_keyconfigs", text=text)
         row.operator("wm.keyconfig_preset_add", text="", icon="ZOOMIN")
         row.operator("wm.keyconfig_preset_add", text="", icon="ZOOMOUT").remove_active = True
@@ -423,7 +424,7 @@ def export_properties(prefix, properties, lines=None):
 class WM_OT_keyconfig_test(Operator):
     "Test keyconfig for conflicts"
     bl_idname = "wm.keyconfig_test"
-    bl_label = "Test Key Configuration for Conflicts"
+    bl_label = _("Test Key Configuration for Conflicts")
 
     def testEntry(self, kc, entry, src=None, parent=None):
         result = False
@@ -597,7 +598,7 @@ class WM_OT_keyconfig_import(Operator):
 class WM_OT_keyconfig_export(Operator):
     "Export key configuration to a python script"
     bl_idname = "wm.keyconfig_export"
-    bl_label = "Export Key Configuration..."
+    bl_label = _("Export Key Configuration...")
 
     filepath = StringProperty(
             name="File Path",
diff --git a/release/scripts/startup/bl_ui/space_view3d.py b/release/scripts/startup/bl_ui/space_view3d.py
index 357c673edbd..2e86e875bab 100644
--- a/release/scripts/startup/bl_ui/space_view3d.py
+++ b/release/scripts/startup/bl_ui/space_view3d.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Operator, Panel
+from blf import gettext as _
 
 
 class VIEW3D_HT_header(Header):
@@ -124,9 +125,9 @@ class ShowHideMenu():
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("%s.reveal" % self._operator_name, text="Show Hidden")
-        layout.operator("%s.hide" % self._operator_name, text="Hide Selected")
-        layout.operator("%s.hide" % self._operator_name, text="Hide Unselected").unselected = True
+        layout.operator("%s.reveal" % self._operator_name, text=_("Show Hidden"))
+        layout.operator("%s.hide" % self._operator_name, text=_("Hide Selected"))
+        layout.operator("%s.hide" % self._operator_name, text=_("Hide Unselected")).unselected = True
 
 
 class VIEW3D_MT_transform(Menu):
@@ -145,35 +146,35 @@ class VIEW3D_MT_transform(Menu):
 
         layout.separator()
 
-        layout.operator("transform.tosphere", text="To Sphere")
-        layout.operator("transform.shear", text="Shear")
-        layout.operator("transform.warp", text="Warp")
-        layout.operator("transform.push_pull", text="Push/Pull")
+        layout.operator("transform.tosphere", text=_("To Sphere"))
+        layout.operator("transform.shear", text=_("Shear"))
+        layout.operator("transform.warp", text=_("Warp"))
+        layout.operator("transform.push_pull", text=_("Push/Pull"))
 
         layout.separator()
 
-        layout.operator("transform.translate", text="Move Texture Space").texture_space = True
-        layout.operator("transform.resize", text="Scale Texture Space").texture_space = True
+        layout.operator("transform.translate", text=_("Move Texture Space")).texture_space = True
+        layout.operator("transform.resize", text=_("Scale Texture Space")).texture_space = True
 
         layout.separator()
 
         obj = context.object
         if obj.type == 'ARMATURE' and obj.mode in {'EDIT', 'POSE'} and obj.data.draw_type in {'BBONE', 'ENVELOPE'}:
-            layout.operator("transform.transform", text="Scale Envelope/BBone").mode = 'BONE_SIZE'
+            layout.operator("transform.transform", text=_("Scale Envelope/BBone")).mode = 'BONE_SIZE'
 
         if context.edit_object and context.edit_object.type == 'ARMATURE':
             layout.operator("armature.align")
         else:
             layout.operator_context = 'EXEC_REGION_WIN'
-            layout.operator("transform.transform", text="Align to Transform Orientation").mode = 'ALIGN'  # XXX see alignmenu() in edit.c of b2.4x to get this working
+            layout.operator("transform.transform", text=_("Align to Transform Orientation")).mode = 'ALIGN'  # XXX see alignmenu() in edit.c of b2.4x to get this working
 
         layout.separator()
 
         layout.operator_context = 'EXEC_AREA'
 
-        layout.operator("object.origin_set", text="Geometry to Origin").type = 'GEOMETRY_ORIGIN'
-        layout.operator("object.origin_set", text="Origin to Geometry").type = 'ORIGIN_GEOMETRY'
-        layout.operator("object.origin_set", text="Origin to 3D Cursor").type = 'ORIGIN_CURSOR'
+        layout.operator("object.origin_set", text=_("Geometry to Origin")).type = 'GEOMETRY_ORIGIN'
+        layout.operator("object.origin_set", text=_("Origin to Geometry")).type = 'ORIGIN_GEOMETRY'
+        layout.operator("object.origin_set", text=_("Origin to 3D Cursor")).type = 'ORIGIN_CURSOR'
 
         layout.separator()
 
@@ -191,32 +192,32 @@ class VIEW3D_MT_mirror(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.mirror", text="Interactive Mirror")
+        layout.operator("transform.mirror", text=_("Interactive Mirror"))
 
         layout.separator()
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        props = layout.operator("transform.mirror", text="X Global")
+        props = layout.operator("transform.mirror", text=_("X Global"))
         props.constraint_axis = (True, False, False)
         props.constraint_orientation = 'GLOBAL'
-        props = layout.operator("transform.mirror", text="Y Global")
+        props = layout.operator("transform.mirror", text=_("Y Global"))
         props.constraint_axis = (False, True, False)
         props.constraint_orientation = 'GLOBAL'
-        props = layout.operator("transform.mirror", text="Z Global")
+        props = layout.operator("transform.mirror", text=_("Z Global"))
         props.constraint_axis = (False, False, True)
         props.constraint_orientation = 'GLOBAL'
 
         if context.edit_object:
             layout.separator()
 
-            props = layout.operator("transform.mirror", text="X Local")
+            props = layout.operator("transform.mirror", text=_("X Local"))
             props.constraint_axis = (True, False, False)
             props.constraint_orientation = 'LOCAL'
-            props = layout.operator("transform.mirror", text="Y Local")
+            props = layout.operator("transform.mirror", text=_("Y Local"))
             props.constraint_axis = (False, True, False)
             props.constraint_orientation = 'LOCAL'
-            props = layout.operator("transform.mirror", text="Z Local")
+            props = layout.operator("transform.mirror", text=_("Z Local"))
             props.constraint_axis = (False, False, True)
             props.constraint_orientation = 'LOCAL'
 
@@ -229,15 +230,15 @@ class VIEW3D_MT_snap(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("view3d.snap_selected_to_grid", text="Selection to Grid")
-        layout.operator("view3d.snap_selected_to_cursor", text="Selection to Cursor")
+        layout.operator("view3d.snap_selected_to_grid", text=_("Selection to Grid"))
+        layout.operator("view3d.snap_selected_to_cursor", text=_("Selection to Cursor"))
 
         layout.separator()
 
-        layout.operator("view3d.snap_cursor_to_selected", text="Cursor to Selected")
-        layout.operator("view3d.snap_cursor_to_center", text="Cursor to Center")
-        layout.operator("view3d.snap_cursor_to_grid", text="Cursor to Grid")
-        layout.operator("view3d.snap_cursor_to_active", text="Cursor to Active")
+        layout.operator("view3d.snap_cursor_to_selected", text=_("Cursor to Selected"))
+        layout.operator("view3d.snap_cursor_to_center", text=_("Cursor to Center"))
+        layout.operator("view3d.snap_cursor_to_grid", text=_("Cursor to Grid"))
+        layout.operator("view3d.snap_cursor_to_active", text=_("Cursor to Active"))
 
 
 class VIEW3D_MT_uv_map(Menu):
@@ -263,7 +264,7 @@ class VIEW3D_MT_uv_map(Menu):
         layout.separator()
 
         layout.operator("uv.project_from_view")
-        layout.operator("uv.project_from_view", text="Project from View (Bounds)").scale_to_bounds = True
+        layout.operator("uv.project_from_view", text=_("Project from View (Bounds)")).scale_to_bounds = True
 
         layout.separator()
 
@@ -284,15 +285,15 @@ class VIEW3D_MT_view(Menu):
 
         layout.separator()
 
-        layout.operator("view3d.viewnumpad", text="Camera").type = 'CAMERA'
-        layout.operator("view3d.viewnumpad", text="Top").type = 'TOP'
-        layout.operator("view3d.viewnumpad", text="Bottom").type = 'BOTTOM'
-        layout.operator("view3d.viewnumpad", text="Front").type = 'FRONT'
-        layout.operator("view3d.viewnumpad", text="Back").type = 'BACK'
-        layout.operator("view3d.viewnumpad", text="Right").type = 'RIGHT'
-        layout.operator("view3d.viewnumpad", text="Left").type = 'LEFT'
+        layout.operator("view3d.viewnumpad", text=_("Camera")).type = 'CAMERA'
+        layout.operator("view3d.viewnumpad", text=_("Top")).type = 'TOP'
+        layout.operator("view3d.viewnumpad", text=_("Bottom")).type = 'BOTTOM'
+        layout.operator("view3d.viewnumpad", text=_("Front")).type = 'FRONT'
+        layout.operator("view3d.viewnumpad", text=_("Back")).type = 'BACK'
+        layout.operator("view3d.viewnumpad", text=_("Right")).type = 'RIGHT'
+        layout.operator("view3d.viewnumpad", text=_("Left")).type = 'LEFT'
 
-        layout.menu("VIEW3D_MT_view_cameras", text="Cameras")
+        layout.menu("VIEW3D_MT_view_cameras", text=_("Cameras"))
 
         layout.separator()
 
@@ -307,22 +308,22 @@ class VIEW3D_MT_view(Menu):
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("view3d.clip_border", text="Clipping Border...")
-        layout.operator("view3d.zoom_border", text="Zoom Border...")
+        layout.operator("view3d.clip_border", text=_("Clipping Border..."))
+        layout.operator("view3d.zoom_border", text=_("Zoom Border..."))
 
         layout.separator()
 
-        layout.operator("view3d.layers", text="Show All Layers").nr = 0
+        layout.operator("view3d.layers", text=_("Show All Layers")).nr = 0
 
         layout.separator()
 
-        layout.operator("view3d.localview", text="View Global/Local")
+        layout.operator("view3d.localview", text=_("View Global/Local"))
         layout.operator("view3d.view_selected")
         layout.operator("view3d.view_all")
 
         layout.separator()
 
-        layout.operator("screen.animation_play", text="Playback Animation")
+        layout.operator("screen.animation_play", text=_("Playback Animation"))
 
         layout.separator()
 
@@ -345,9 +346,9 @@ class VIEW3D_MT_view_navigation(Menu):
 
         layout.separator()
 
-        layout.operator("view3d.zoom", text="Zoom In").delta = 1
-        layout.operator("view3d.zoom", text="Zoom Out").delta = -1
-        layout.operator("view3d.zoom_camera_1_to_1", text="Zoom Camera 1:1")
+        layout.operator("view3d.zoom", text=_("Zoom In")).delta = 1
+        layout.operator("view3d.zoom", text=_("Zoom Out")).delta = -1
+        layout.operator("view3d.zoom_camera_1_to_1", text=_("Zoom Camera 1:1"))
 
         layout.separator()
 
@@ -364,8 +365,8 @@ class VIEW3D_MT_view_align(Menu):
 
         layout.separator()
 
-        layout.operator("view3d.view_all", text="Center Cursor and View All").center = True
-        layout.operator("view3d.camera_to_view", text="Align Active Camera to View")
+        layout.operator("view3d.view_all", text=_("Center Cursor and View All")).center = True
+        layout.operator("view3d.camera_to_view", text=_("Align Active Camera to View"))
         layout.operator("view3d.view_selected")
         layout.operator("view3d.view_center_cursor")
 
@@ -376,22 +377,22 @@ class VIEW3D_MT_view_align_selected(Menu):
     def draw(self, context):
         layout = self.layout
 
-        props = layout.operator("view3d.viewnumpad", text="Top")
+        props = layout.operator("view3d.viewnumpad", text=_("Top"))
         props.align_active = True
         props.type = 'TOP'
-        props = layout.operator("view3d.viewnumpad", text="Bottom")
+        props = layout.operator("view3d.viewnumpad", text=_("Bottom"))
         props.align_active = True
         props.type = 'BOTTOM'
-        props = layout.operator("view3d.viewnumpad", text="Front")
+        props = layout.operator("view3d.viewnumpad", text=_("Front"))
         props.align_active = True
         props.type = 'FRONT'
-        props = layout.operator("view3d.viewnumpad", text="Back")
+        props = layout.operator("view3d.viewnumpad", text=_("Back"))
         props.align_active = True
         props.type = 'BACK'
-        props = layout.operator("view3d.viewnumpad", text="Right")
+        props = layout.operator("view3d.viewnumpad", text=_("Right"))
         props.align_active = True
         props.type = 'RIGHT'
-        props = layout.operator("view3d.viewnumpad", text="Left")
+        props = layout.operator("view3d.viewnumpad", text=_("Left"))
         props.align_active = True
         props.type = 'LEFT'
 
@@ -403,7 +404,7 @@ class VIEW3D_MT_view_cameras(Menu):
         layout = self.layout
 
         layout.operator("view3d.object_as_camera")
-        layout.operator("view3d.viewnumpad", text="Active Camera").type = 'CAMERA'
+        layout.operator("view3d.viewnumpad", text=_("Active Camera")).type = 'CAMERA'
 
 # ********** Select menus, suffix from context.mode **********
 
@@ -419,19 +420,19 @@ class VIEW3D_MT_select_object(Menu):
 
         layout.separator()
 
-        layout.operator("object.select_all", text="Select/Deselect All")
-        layout.operator("object.select_inverse", text="Inverse")
-        layout.operator("object.select_random", text="Random")
-        layout.operator("object.select_mirror", text="Mirror")
-        layout.operator("object.select_by_layer", text="Select All by Layer")
-        layout.operator_menu_enum("object.select_by_type", "type", text="Select All by Type...")
-        layout.operator("object.select_camera", text="Select Camera")
+        layout.operator("object.select_all", text=_("Select/Deselect All"))
+        layout.operator("object.select_inverse", text=_("Inverse"))
+        layout.operator("object.select_random", text=_("Random"))
+        layout.operator("object.select_mirror", text=_("Mirror"))
+        layout.operator("object.select_by_layer", text=_("Select All by Layer"))
+        layout.operator_menu_enum("object.select_by_type", "type", text=_("Select All by Type..."))
+        layout.operator("object.select_camera", text=_("Select Camera"))
 
         layout.separator()
 
-        layout.operator_menu_enum("object.select_grouped", "type", text="Grouped")
-        layout.operator_menu_enum("object.select_linked", "type", text="Linked")
-        layout.operator("object.select_pattern", text="Select Pattern...")
+        layout.operator_menu_enum("object.select_grouped", "type", text=_("Grouped"))
+        layout.operator_menu_enum("object.select_linked", "type", text=_("Linked"))
+        layout.operator("object.select_pattern", text=_("Select Pattern..."))
 
 
 class VIEW3D_MT_select_pose(Menu):
@@ -444,31 +445,31 @@ class VIEW3D_MT_select_pose(Menu):
 
         layout.separator()
 
-        layout.operator("pose.select_all", text="Select/Deselect All")
-        layout.operator("pose.select_inverse", text="Inverse")
-        layout.operator("pose.select_flip_active", text="Flip Active")
-        layout.operator("pose.select_constraint_target", text="Constraint Target")
-        layout.operator("pose.select_linked", text="Linked")
+        layout.operator("pose.select_all", text=_("Select/Deselect All"))
+        layout.operator("pose.select_inverse", text=_("Inverse"))
+        layout.operator("pose.select_flip_active", text=_("Flip Active"))
+        layout.operator("pose.select_constraint_target", text=_("Constraint Target"))
+        layout.operator("pose.select_linked", text=_("Linked"))
 
         layout.separator()
 
-        layout.operator("pose.select_hierarchy", text="Parent").direction = 'PARENT'
-        layout.operator("pose.select_hierarchy", text="Child").direction = 'CHILD'
+        layout.operator("pose.select_hierarchy", text=_("Parent")).direction = 'PARENT'
+        layout.operator("pose.select_hierarchy", text=_("Child")).direction = 'CHILD'
 
         layout.separator()
 
-        props = layout.operator("pose.select_hierarchy", text="Extend Parent")
+        props = layout.operator("pose.select_hierarchy", text=_("Extend Parent"))
         props.extend = True
         props.direction = 'PARENT'
 
-        props = layout.operator("pose.select_hierarchy", text="Extend Child")
+        props = layout.operator("pose.select_hierarchy", text=_("Extend Child"))
         props.extend = True
         props.direction = 'CHILD'
 
         layout.separator()
 
-        layout.operator_menu_enum("pose.select_grouped", "type", text="Grouped")
-        layout.operator("object.select_pattern", text="Select Pattern...")
+        layout.operator_menu_enum("pose.select_grouped", "type", text=_("Grouped"))
+        layout.operator("object.select_pattern", text=_("Select Pattern..."))
 
 
 class VIEW3D_MT_select_particle(Menu):
@@ -481,7 +482,7 @@ class VIEW3D_MT_select_particle(Menu):
 
         layout.separator()
 
-        layout.operator("particle.select_all", text="Select/Deselect All")
+        layout.operator("particle.select_all", text=_("Select/Deselect All"))
         layout.operator("particle.select_linked")
         layout.operator("particle.select_inverse")
 
@@ -492,8 +493,8 @@ class VIEW3D_MT_select_particle(Menu):
 
         layout.separator()
 
-        layout.operator("particle.select_roots", text="Roots")
-        layout.operator("particle.select_tips", text="Tips")
+        layout.operator("particle.select_roots", text=_("Roots"))
+        layout.operator("particle.select_tips", text=_("Tips"))
 
 
 class VIEW3D_MT_select_edit_mesh(Menu):
@@ -507,40 +508,40 @@ class VIEW3D_MT_select_edit_mesh(Menu):
 
         layout.separator()
 
-        layout.operator("mesh.select_all", text="Select/Deselect All")
-        layout.operator("mesh.select_inverse", text="Inverse")
+        layout.operator("mesh.select_all", text=_("Select/Deselect All"))
+        layout.operator("mesh.select_inverse", text=_("Inverse"))
 
         layout.separator()
 
-        layout.operator("mesh.select_random", text="Random")
-        layout.operator("mesh.select_nth", text="Every N Number of Verts")
-        layout.operator("mesh.edges_select_sharp", text="Sharp Edges")
-        layout.operator("mesh.faces_select_linked_flat", text="Linked Flat Faces")
-        layout.operator("mesh.faces_select_interior", text="Interior Faces")
-        layout.operator("mesh.select_axis", text="Side of Active")
+        layout.operator("mesh.select_random", text=_("Random"))
+        layout.operator("mesh.select_nth", text=_("Every N Number of Verts"))
+        layout.operator("mesh.edges_select_sharp", text=_("Sharp Edges"))
+        layout.operator("mesh.faces_select_linked_flat", text=_("Linked Flat Faces"))
+        layout.operator("mesh.faces_select_interior", text=_("Interior Faces"))
+        layout.operator("mesh.select_axis", text=_("Side of Active"))
 
         layout.separator()
 
-        layout.operator("mesh.select_by_number_vertices", text="Triangles").type = 'TRIANGLES'
-        layout.operator("mesh.select_by_number_vertices", text="Quads").type = 'QUADS'
+        layout.operator("mesh.select_by_number_vertices", text=_("Triangles")).type = 'TRIANGLES'
+        layout.operator("mesh.select_by_number_vertices", text=_("Quads")).type = 'QUADS'
         if context.scene.tool_settings.mesh_select_mode[2] == False:
-                layout.operator("mesh.select_non_manifold", text="Non Manifold")
-        layout.operator("mesh.select_by_number_vertices", text="Loose Verts/Edges").type = 'OTHER'
-        layout.operator("mesh.select_similar", text="Similar")
+                layout.operator("mesh.select_non_manifold", text=_("Non Manifold"))
+        layout.operator("mesh.select_by_number_vertices", text=_("Loose Verts/Edges")).type = 'OTHER'
+        layout.operator("mesh.select_similar", text=_("Similar"))
 
         layout.separator()
 
-        layout.operator("mesh.select_less", text="Less")
-        layout.operator("mesh.select_more", text="More")
+        layout.operator("mesh.select_less", text=_("Less"))
+        layout.operator("mesh.select_more", text=_("More"))
 
         layout.separator()
 
-        layout.operator("mesh.select_mirror", text="Mirror")
+        layout.operator("mesh.select_mirror", text=_("Mirror"))
 
-        layout.operator("mesh.select_linked", text="Linked")
-        layout.operator("mesh.select_vertex_path", text="Vertex Path")
-        layout.operator("mesh.loop_multi_select", text="Edge Loop")
-        layout.operator("mesh.loop_multi_select", text="Edge Ring").ring = True
+        layout.operator("mesh.select_linked", text=_("Linked"))
+        layout.operator("mesh.select_vertex_path", text=_("Vertex Path"))
+        layout.operator("mesh.loop_multi_select", text=_("Edge Loop"))
+        layout.operator("mesh.loop_multi_select", text=_("Edge Ring")).ring = True
 
         layout.separator()
 
@@ -559,10 +560,10 @@ class VIEW3D_MT_select_edit_curve(Menu):
 
         layout.separator()
 
-        layout.operator("curve.select_all", text="Select/Deselect All")
+        layout.operator("curve.select_all", text=_("Select/Deselect All"))
         layout.operator("curve.select_inverse")
         layout.operator("curve.select_random")
-        layout.operator("curve.select_nth", text="Every Nth Number of Points")
+        layout.operator("curve.select_nth", text=_("Every Nth Number of Points"))
 
         layout.separator()
 
@@ -588,10 +589,10 @@ class VIEW3D_MT_select_edit_surface(Menu):
 
         layout.separator()
 
-        layout.operator("curve.select_all", text="Select/Deselect All")
+        layout.operator("curve.select_all", text=_("Select/Deselect All"))
         layout.operator("curve.select_inverse")
         layout.operator("curve.select_random")
-        layout.operator("curve.select_nth", text="Every Nth Number of Points")
+        layout.operator("curve.select_nth", text=_("Every Nth Number of Points"))
 
         layout.separator()
 
@@ -631,7 +632,7 @@ class VIEW3D_MT_select_edit_lattice(Menu):
 
         layout.separator()
 
-        layout.operator("lattice.select_all", text="Select/Deselect All")
+        layout.operator("lattice.select_all", text=_("Select/Deselect All"))
 
 
 class VIEW3D_MT_select_edit_armature(Menu):
@@ -644,25 +645,25 @@ class VIEW3D_MT_select_edit_armature(Menu):
 
         layout.separator()
 
-        layout.operator("armature.select_all", text="Select/Deselect All")
-        layout.operator("armature.select_inverse", text="Inverse")
+        layout.operator("armature.select_all", text=_("Select/Deselect All"))
+        layout.operator("armature.select_inverse", text=_("Inverse"))
 
         layout.separator()
 
-        layout.operator("armature.select_hierarchy", text="Parent").direction = 'PARENT'
-        layout.operator("armature.select_hierarchy", text="Child").direction = 'CHILD'
+        layout.operator("armature.select_hierarchy", text=_("Parent")).direction = 'PARENT'
+        layout.operator("armature.select_hierarchy", text=_("Child")).direction = 'CHILD'
 
         layout.separator()
 
-        props = layout.operator("armature.select_hierarchy", text="Extend Parent")
+        props = layout.operator("armature.select_hierarchy", text=_("Extend Parent"))
         props.extend = True
         props.direction = 'PARENT'
 
-        props = layout.operator("armature.select_hierarchy", text="Extend Child")
+        props = layout.operator("armature.select_hierarchy", text=_("Extend Child"))
         props.extend = True
         props.direction = 'CHILD'
 
-        layout.operator("object.select_pattern", text="Select Pattern...")
+        layout.operator("object.select_pattern", text=_("Select Pattern..."))
 
 
 class VIEW3D_MT_select_face(Menu):  # XXX no matching enum
@@ -705,11 +706,11 @@ class VIEW3D_MT_object(Menu):
 
         layout.operator("object.duplicate_move")
         layout.operator("object.duplicate_move_linked")
-        layout.operator("object.delete", text="Delete...")
-        layout.operator("object.proxy_make", text="Make Proxy...")
-        layout.menu("VIEW3D_MT_make_links", text="Make Links...")
+        layout.operator("object.delete", text=_("Delete..."))
+        layout.operator("object.proxy_make", text=_("Make Proxy..."))
+        layout.menu("VIEW3D_MT_make_links", text=_("Make Links..."))
         layout.operator("object.make_dupli_face")
-        layout.operator_menu_enum("object.make_local", "type", text="Make Local...")
+        layout.operator_menu_enum("object.make_local", "type", text=_("Make Local..."))
         layout.menu("VIEW3D_MT_make_single_user")
 
         layout.separator()
@@ -730,7 +731,7 @@ class VIEW3D_MT_object(Menu):
 
         layout.separator()
 
-        layout.operator("object.move_to_layer", text="Move to Layer...")
+        layout.operator("object.move_to_layer", text=_("Move to Layer..."))
         layout.menu("VIEW3D_MT_object_showhide")
 
         layout.operator_menu_enum("object.convert", "target")
@@ -742,9 +743,9 @@ class VIEW3D_MT_object_animation(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("anim.keyframe_insert_menu", text="Insert Keyframe...")
-        layout.operator("anim.keyframe_delete_v3d", text="Delete Keyframe...")
-        layout.operator("anim.keying_set_active_set", text="Change Keying Set...")
+        layout.operator("anim.keyframe_insert_menu", text=_("Insert Keyframe..."))
+        layout.operator("anim.keyframe_delete_v3d", text=_("Delete Keyframe..."))
+        layout.operator("anim.keying_set_active_set", text=_("Change Keying Set..."))
 
 
 class VIEW3D_MT_object_clear(Menu):
@@ -753,10 +754,10 @@ class VIEW3D_MT_object_clear(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("object.location_clear", text="Location")
-        layout.operator("object.rotation_clear", text="Rotation")
-        layout.operator("object.scale_clear", text="Scale")
-        layout.operator("object.origin_clear", text="Origin")
+        layout.operator("object.location_clear", text=_("Location"))
+        layout.operator("object.rotation_clear", text=_("Rotation"))
+        layout.operator("object.scale_clear", text=_("Scale"))
+        layout.operator("object.origin_clear", text=_("Origin"))
 
 
 class VIEW3D_MT_object_specials(Menu):
@@ -775,19 +776,19 @@ class VIEW3D_MT_object_specials(Menu):
             layout.operator_context = 'INVOKE_REGION_WIN'
 
             if obj.data.type == 'PERSP':
-                props = layout.operator("wm.context_modal_mouse", text="Camera Lens Angle")
+                props = layout.operator("wm.context_modal_mouse", text=_("Camera Lens Angle"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.lens"
                 props.input_scale = 0.1
             else:
-                props = layout.operator("wm.context_modal_mouse", text="Camera Lens Scale")
+                props = layout.operator("wm.context_modal_mouse", text=_("Camera Lens Scale"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.ortho_scale"
                 props.input_scale = 0.01
 
             if not obj.data.dof_object:
                 #layout.label(text="Test Has DOF obj");
-                props = layout.operator("wm.context_modal_mouse", text="DOF Distance")
+                props = layout.operator("wm.context_modal_mouse", text=_("DOF Distance"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.dof_distance"
                 props.input_scale = 0.02
@@ -795,12 +796,12 @@ class VIEW3D_MT_object_specials(Menu):
         if obj.type in {'CURVE', 'FONT'}:
             layout.operator_context = 'INVOKE_REGION_WIN'
 
-            props = layout.operator("wm.context_modal_mouse", text="Extrude Size")
+            props = layout.operator("wm.context_modal_mouse", text=_("Extrude Size"))
             props.data_path_iter = "selected_editable_objects"
             props.data_path_item = "data.extrude"
             props.input_scale = 0.01
 
-            props = layout.operator("wm.context_modal_mouse", text="Width Size")
+            props = layout.operator("wm.context_modal_mouse", text=_("Width Size"))
             props.data_path_iter = "selected_editable_objects"
             props.data_path_item = "data.offset"
             props.input_scale = 0.01
@@ -808,7 +809,7 @@ class VIEW3D_MT_object_specials(Menu):
         if obj.type == 'EMPTY':
             layout.operator_context = 'INVOKE_REGION_WIN'
 
-            props = layout.operator("wm.context_modal_mouse", text="Empty Draw Size")
+            props = layout.operator("wm.context_modal_mouse", text=_("Empty Draw Size"))
             props.data_path_iter = "selected_editable_objects"
             props.data_path_item = "empty_draw_size"
             props.input_scale = 0.01
@@ -816,34 +817,34 @@ class VIEW3D_MT_object_specials(Menu):
         if obj.type == 'LAMP':
             layout.operator_context = 'INVOKE_REGION_WIN'
 
-            props = layout.operator("wm.context_modal_mouse", text="Energy")
+            props = layout.operator("wm.context_modal_mouse", text=_("Energy"))
             props.data_path_iter = "selected_editable_objects"
             props.data_path_item = "data.energy"
 
             if obj.data.type in {'SPOT', 'AREA', 'POINT'}:
-                props = layout.operator("wm.context_modal_mouse", text="Falloff Distance")
+                props = layout.operator("wm.context_modal_mouse", text=_("Falloff Distance"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.distance"
                 props.input_scale = 0.1
 
             if obj.data.type == 'SPOT':
                 layout.separator()
-                props = layout.operator("wm.context_modal_mouse", text="Spot Size")
+                props = layout.operator("wm.context_modal_mouse", text=_("Spot Size"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.spot_size"
                 props.input_scale = 0.01
 
-                props = layout.operator("wm.context_modal_mouse", text="Spot Blend")
+                props = layout.operator("wm.context_modal_mouse", text=_("Spot Blend"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.spot_blend"
                 props.input_scale = -0.01
 
-                props = layout.operator("wm.context_modal_mouse", text="Clip Start")
+                props = layout.operator("wm.context_modal_mouse", text=_("Clip Start"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.shadow_buffer_clip_start"
                 props.input_scale = 0.05
 
-                props = layout.operator("wm.context_modal_mouse", text="Clip End")
+                props = layout.operator("wm.context_modal_mouse", text=_("Clip End"))
                 props.data_path_iter = "selected_editable_objects"
                 props.data_path_item = "data.shadow_buffer_clip_end"
                 props.input_scale = 0.05
@@ -860,16 +861,16 @@ class VIEW3D_MT_object_apply(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("object.transform_apply", text="Location").location = True
-        layout.operator("object.transform_apply", text="Rotation").rotation = True
-        layout.operator("object.transform_apply", text="Scale").scale = True
-        props = layout.operator("object.transform_apply", text="Rotation & Scale")
+        layout.operator("object.transform_apply", text=_("Location")).location = True
+        layout.operator("object.transform_apply", text=_("Rotation")).rotation = True
+        layout.operator("object.transform_apply", text=_("Scale")).scale = True
+        props = layout.operator("object.transform_apply", text=_("Rotation & Scale"))
         props.scale = True
         props.rotation = True
 
         layout.separator()
 
-        layout.operator("object.visual_transform_apply", text="Visual Transform")
+        layout.operator("object.visual_transform_apply", text=_("Visual Transform"))
         layout.operator("object.duplicates_make_real")
 
 
@@ -879,8 +880,8 @@ class VIEW3D_MT_object_parent(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("object.parent_set", text="Set")
-        layout.operator("object.parent_clear", text="Clear")
+        layout.operator("object.parent_set", text=_("Set"))
+        layout.operator("object.parent_clear", text=_("Clear"))
 
 
 class VIEW3D_MT_object_track(Menu):
@@ -889,8 +890,8 @@ class VIEW3D_MT_object_track(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("object.track_set", text="Set")
-        layout.operator("object.track_clear", text="Clear")
+        layout.operator("object.track_set", text=_("Set"))
+        layout.operator("object.track_clear", text=_("Clear"))
 
 
 class VIEW3D_MT_object_group(Menu):
@@ -925,9 +926,9 @@ class VIEW3D_MT_object_showhide(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("object.hide_view_clear", text="Show Hidden")
-        layout.operator("object.hide_view_set", text="Hide Selected")
-        layout.operator("object.hide_view_set", text="Hide Unselected").unselected = True
+        layout.operator("object.hide_view_clear", text=_("Show Hidden"))
+        layout.operator("object.hide_view_set", text=_("Hide Selected"))
+        layout.operator("object.hide_view_set", text=_("Hide Unselected")).unselected = True
 
 
 class VIEW3D_MT_make_single_user(Menu):
@@ -936,19 +937,19 @@ class VIEW3D_MT_make_single_user(Menu):
     def draw(self, context):
         layout = self.layout
 
-        props = layout.operator("object.make_single_user", text="Object")
+        props = layout.operator("object.make_single_user", text=_("Object"))
         props.object = True
 
-        props = layout.operator("object.make_single_user", text="Object & Data")
+        props = layout.operator("object.make_single_user", text=_("Object & Data"))
         props.object = props.obdata = True
 
-        props = layout.operator("object.make_single_user", text="Object & Data & Materials+Tex")
+        props = layout.operator("object.make_single_user", text=_("Object & Data & Materials+Tex"))
         props.object = props.obdata = props.material = props.texture = True
 
-        props = layout.operator("object.make_single_user", text="Materials+Tex")
+        props = layout.operator("object.make_single_user", text=_("Materials+Tex"))
         props.material = props.texture = True
 
-        props = layout.operator("object.make_single_user", text="Object Animation")
+        props = layout.operator("object.make_single_user", text=_("Object Animation"))
         props.animation = True
 
 
@@ -960,11 +961,11 @@ class VIEW3D_MT_make_links(Menu):
 
         if(len(bpy.data.scenes) > 10):
             layout.operator_context = 'INVOKE_DEFAULT'
-            layout.operator("object.make_links_scene", text="Objects to Scene...", icon='OUTLINER_OB_EMPTY')
-            layout.operator("object.make_links_scene", text="Markers to Scene...", icon='OUTLINER_OB_EMPTY')
+            layout.operator("object.make_links_scene", text=_("Objects to Scene..."), icon='OUTLINER_OB_EMPTY')
+            layout.operator("object.make_links_scene", text=_("Markers to Scene..."), icon='OUTLINER_OB_EMPTY')
         else:
-            layout.operator_menu_enum("object.make_links_scene", "scene", text="Objects to Scene...")
-            layout.operator_menu_enum("marker.make_links_scene", "scene", text="Markers to Scene...")
+            layout.operator_menu_enum("object.make_links_scene", "scene", text=_("Objects to Scene..."))
+            layout.operator_menu_enum("marker.make_links_scene", "scene", text=_("Markers to Scene..."))
 
         layout.operator_enum("object.make_links_data", "type")  # inline
 
@@ -975,13 +976,13 @@ class VIEW3D_MT_object_game(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("object.logic_bricks_copy", text="Copy Logic Bricks")
+        layout.operator("object.logic_bricks_copy", text=_("Copy Logic Bricks"))
 
         layout.separator()
 
-        layout.operator("object.game_property_copy", text="Replace Properties").operation = 'REPLACE'
-        layout.operator("object.game_property_copy", text="Merge Properties").operation = 'MERGE'
-        layout.operator_menu_enum("object.game_property_copy", "property", text="Copy Properties...")
+        layout.operator("object.game_property_copy", text=_("Replace Properties")).operation = 'REPLACE'
+        layout.operator("object.game_property_copy", text=_("Merge Properties")).operation = 'MERGE'
+        layout.operator_menu_enum("object.game_property_copy", "property", text=_("Copy Properties..."))
 
         layout.separator()
 
@@ -1031,21 +1032,21 @@ class VIEW3D_MT_vertex_group(Menu):
     def draw(self, context):
         layout = self.layout
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("object.vertex_group_assign", text="Assign to New Group").new = True
+        layout.operator("object.vertex_group_assign", text=_("Assign to New Group")).new = True
 
         ob = context.active_object
         if ob.mode == 'EDIT':
             if ob.vertex_groups.active:
                 layout.separator()
-                layout.operator("object.vertex_group_assign", text="Assign to Active Group")
-                layout.operator("object.vertex_group_remove_from", text="Remove from Active Group")
-                layout.operator("object.vertex_group_remove_from", text="Remove from All").all = True
+                layout.operator("object.vertex_group_assign", text=_("Assign to Active Group"))
+                layout.operator("object.vertex_group_remove_from", text=_("Remove from Active Group"))
+                layout.operator("object.vertex_group_remove_from", text=_("Remove from All")).all = True
                 layout.separator()
 
         if ob.vertex_groups.active:
-            layout.operator_menu_enum("object.vertex_group_set_active", "group", text="Set Active Group")
-            layout.operator("object.vertex_group_remove", text="Remove Active Group")
-            layout.operator("object.vertex_group_remove", text="Remove All Groups").all = True
+            layout.operator_menu_enum("object.vertex_group_set_active", "group", text=_("Set Active Group"))
+            layout.operator("object.vertex_group_remove", text=_("Remove Active Group"))
+            layout.operator("object.vertex_group_remove", text=_("Remove All Groups")).all = True
 
 # ********** Weight paint menu **********
 
@@ -1062,16 +1063,16 @@ class VIEW3D_MT_paint_weight(Menu):
 
         layout.separator()
 
-        layout.operator("paint.weight_from_bones", text="Assign Automatic From Bones").type = 'AUTOMATIC'
-        layout.operator("paint.weight_from_bones", text="Assign From Bone Envelopes").type = 'ENVELOPES'
+        layout.operator("paint.weight_from_bones", text=_("Assign Automatic From Bones")).type = 'AUTOMATIC'
+        layout.operator("paint.weight_from_bones", text=_("Assign From Bone Envelopes")).type = 'ENVELOPES'
 
         layout.separator()
 
-        layout.operator("object.vertex_group_normalize_all", text="Normalize All")
-        layout.operator("object.vertex_group_normalize", text="Normalize")
-        layout.operator("object.vertex_group_invert", text="Invert")
-        layout.operator("object.vertex_group_clean", text="Clean")
-        layout.operator("object.vertex_group_levels", text="Levels")
+        layout.operator("object.vertex_group_normalize_all", text=_("Normalize All"))
+        layout.operator("object.vertex_group_normalize", text=_("Normalize"))
+        layout.operator("object.vertex_group_invert", text=_("Invert"))
+        layout.operator("object.vertex_group_clean", text=_("Clean"))
+        layout.operator("object.vertex_group_levels", text=_("Levels"))
         layout.operator("object.vertex_group_fix", text="Fix Deforms")
 
         layout.separator()
@@ -1121,12 +1122,12 @@ class VIEW3D_MT_sculpt(Menu):
                     layout.operator("sculpt.set_persistent_base")
 
         layout.separator()
-        layout.prop(sculpt, "use_threaded", text="Threaded Sculpt")
+        layout.prop(sculpt, "use_threaded", text=_("Threaded Sculpt"))
         layout.prop(sculpt, "show_brush")
 
         # TODO, make availabel from paint menu!
-        layout.prop(tool_settings, "sculpt_paint_use_unified_size", text="Unify Size")
-        layout.prop(tool_settings, "sculpt_paint_use_unified_strength", text="Unify Strength")
+        layout.prop(tool_settings, "sculpt_paint_use_unified_size", text=_("Unify Size"))
+        layout.prop(tool_settings, "sculpt_paint_use_unified_strength", text=_("Unify Strength"))
 
 # ********** Particle menu **********
 
@@ -1219,7 +1220,7 @@ class VIEW3D_MT_pose(Menu):
 
         layout.operator("pose.copy")
         layout.operator("pose.paste")
-        layout.operator("pose.paste", text="Paste X-Flipped Pose").flipped = True
+        layout.operator("pose.paste", text=_("Paste X-Flipped Pose")).flipped = True
 
         layout.separator()
 
@@ -1236,9 +1237,9 @@ class VIEW3D_MT_pose(Menu):
         layout.separator()
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("pose.autoside_names", text="AutoName Left/Right").axis = 'XAXIS'
-        layout.operator("pose.autoside_names", text="AutoName Front/Back").axis = 'YAXIS'
-        layout.operator("pose.autoside_names", text="AutoName Top/Bottom").axis = 'ZAXIS'
+        layout.operator("pose.autoside_names", text=_("AutoName Left/Right")).axis = 'XAXIS'
+        layout.operator("pose.autoside_names", text=_("AutoName Front/Back")).axis = 'YAXIS'
+        layout.operator("pose.autoside_names", text=_("AutoName Top/Bottom")).axis = 'ZAXIS'
 
         layout.operator("pose.flip_names")
 
@@ -1247,13 +1248,13 @@ class VIEW3D_MT_pose(Menu):
         layout.separator()
 
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("pose.armature_layers", text="Change Armature Layers...")
-        layout.operator("pose.bone_layers", text="Change Bone Layers...")
+        layout.operator("pose.armature_layers", text=_("Change Armature Layers..."))
+        layout.operator("pose.bone_layers", text=_("Change Bone Layers..."))
 
         layout.separator()
 
         layout.menu("VIEW3D_MT_pose_showhide")
-        layout.menu("VIEW3D_MT_bone_options_toggle", text="Bone Settings")
+        layout.menu("VIEW3D_MT_bone_options_toggle", text=_("Bone Settings"))
 
 
 class VIEW3D_MT_pose_transform(Menu):
@@ -1262,17 +1263,17 @@ class VIEW3D_MT_pose_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("pose.transforms_clear", text="All")
+        layout.operator("pose.transforms_clear", text=_("All"))
 
         layout.separator()
 
-        layout.operator("pose.loc_clear", text="Location")
-        layout.operator("pose.rot_clear", text="Rotation")
-        layout.operator("pose.scale_clear", text="Scale")
+        layout.operator("pose.loc_clear", text=_("Location"))
+        layout.operator("pose.rot_clear", text=_("Rotation"))
+        layout.operator("pose.scale_clear", text=_("Scale"))
 
         layout.separator()
 
-        layout.operator("pose.user_transforms_clear", text="Reset unkeyed")
+        layout.operator("pose.user_transforms_clear", text=_("Reset unkeyed"))
 
 
 class VIEW3D_MT_pose_slide(Menu):
@@ -1296,12 +1297,12 @@ class VIEW3D_MT_pose_propagate(Menu):
 
         layout.separator()
 
-        layout.operator("pose.propagate", text="To Next Keyframe").mode = 'NEXT_KEY'
-        layout.operator("pose.propagate", text="To Last Keyframe (Make Cyclic)").mode = 'LAST_KEY'
+        layout.operator("pose.propagate", text=_("To Next Keyframe")).mode = 'NEXT_KEY'
+        layout.operator("pose.propagate", text=_("To Last Keyframe (Make Cyclic)")).mode = 'LAST_KEY'
 
         layout.separator()
 
-        layout.operator("pose.propagate", text="On Selected Markers").mode = 'SELECTED_MARKERS'
+        layout.operator("pose.propagate", text=_("On Selected Markers")).mode = 'SELECTED_MARKERS'
 
 
 class VIEW3D_MT_pose_library(Menu):
@@ -1310,13 +1311,13 @@ class VIEW3D_MT_pose_library(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("poselib.browse_interactive", text="Browse Poses...")
+        layout.operator("poselib.browse_interactive", text=_("Browse Poses..."))
 
         layout.separator()
 
-        layout.operator("poselib.pose_add", text="Add Pose...")
-        layout.operator("poselib.pose_rename", text="Rename Pose...")
-        layout.operator("poselib.pose_remove", text="Remove Pose...")
+        layout.operator("poselib.pose_add", text=_("Add Pose..."))
+        layout.operator("poselib.pose_rename", text=_("Rename Pose..."))
+        layout.operator("poselib.pose_remove", text=_("Remove Pose..."))
 
 
 class VIEW3D_MT_pose_motion(Menu):
@@ -1325,8 +1326,8 @@ class VIEW3D_MT_pose_motion(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("pose.paths_calculate", text="Calculate")
-        layout.operator("pose.paths_clear", text="Clear")
+        layout.operator("pose.paths_calculate", text=_("Calculate"))
+        layout.operator("pose.paths_clear", text=_("Clear"))
 
 
 class VIEW3D_MT_pose_group(Menu):
@@ -1359,7 +1360,7 @@ class VIEW3D_MT_pose_constraints(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("pose.constraint_add_with_targets", text="Add (With Targets)...")
+        layout.operator("pose.constraint_add_with_targets", text=_("Add (With Targets)..."))
         layout.operator("pose.constraints_copy")
         layout.operator("pose.constraints_clear")
 
@@ -1369,7 +1370,7 @@ class VIEW3D_MT_pose_showhide(ShowHideMenu, Menu):
 
 
 class VIEW3D_MT_pose_apply(Menu):
-    bl_label = "Apply"
+    bl_label = _("Apply")
 
     def draw(self, context):
         layout = self.layout
@@ -1444,14 +1445,14 @@ class VIEW3D_MT_edit_mesh(Menu):
 
         layout.separator()
 
-        layout.menu("VIEW3D_MT_uv_map", text="UV Unwrap...")
+        layout.menu("VIEW3D_MT_uv_map", text=_("UV Unwrap..."))
 
         layout.separator()
 
-        layout.operator("view3d.edit_mesh_extrude_move_normal", text="Extrude Region")
-        layout.operator("view3d.edit_mesh_extrude_individual_move", text="Extrude Individual")
+        layout.operator("view3d.edit_mesh_extrude_move_normal", text=_("Extrude Region"))
+        layout.operator("view3d.edit_mesh_extrude_individual_move", text=_("Extrude Individual"))
         layout.operator("mesh.duplicate_move")
-        layout.operator("mesh.delete", text="Delete...")
+        layout.operator("mesh.delete", text=_("Delete..."))
 
         layout.separator()
 
@@ -1479,15 +1480,15 @@ class VIEW3D_MT_edit_mesh_specials(Menu):
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("mesh.subdivide", text="Subdivide")
-        layout.operator("mesh.subdivide", text="Subdivide Smooth").smoothness = 1.0
-        layout.operator("mesh.merge", text="Merge...")
+        layout.operator("mesh.subdivide", text=_("Subdivide"))
+        layout.operator("mesh.subdivide", text=_("Subdivide Smooth")).smoothness = 1.0
+        layout.operator("mesh.merge", text=_("Merge..."))
         layout.operator("mesh.remove_doubles")
-        layout.operator("mesh.hide", text="Hide")
-        layout.operator("mesh.reveal", text="Reveal")
+        layout.operator("mesh.hide", text=_("Hide"))
+        layout.operator("mesh.reveal", text=_("Reveal"))
         layout.operator("mesh.select_inverse")
         layout.operator("mesh.flip_normals")
-        layout.operator("mesh.vertices_smooth", text="Smooth")
+        layout.operator("mesh.vertices_smooth", text=_("Smooth"))
         # layout.operator("mesh.bevel", text="Bevel")
         layout.operator("mesh.faces_shade_smooth")
         layout.operator("mesh.faces_shade_flat")
@@ -1504,15 +1505,15 @@ class VIEW3D_MT_edit_mesh_select_mode(Menu):
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        prop = layout.operator("wm.context_set_value", text="Vertex", icon='VERTEXSEL')
+        prop = layout.operator("wm.context_set_value", text=_("Vertex"), icon='VERTEXSEL')
         prop.value = "(True, False, False)"
         prop.data_path = "tool_settings.mesh_select_mode"
 
-        prop = layout.operator("wm.context_set_value", text="Edge", icon='EDGESEL')
+        prop = layout.operator("wm.context_set_value", text=_("Edge"), icon='EDGESEL')
         prop.value = "(False, True, False)"
         prop.data_path = "tool_settings.mesh_select_mode"
 
-        prop = layout.operator("wm.context_set_value", text="Face", icon='FACESEL')
+        prop = layout.operator("wm.context_set_value", text=_("Face"), icon='FACESEL')
         prop.value = "(False, False, True)"
         prop.data_path = "tool_settings.mesh_select_mode"
 
@@ -1521,10 +1522,10 @@ class VIEW3D_MT_edit_mesh_extrude(Menu):
     bl_label = "Extrude"
 
     _extrude_funcs = { \
-        "VERT": lambda layout: layout.operator("mesh.extrude_vertices_move", text="Vertices Only"),
-        "EDGE": lambda layout: layout.operator("mesh.extrude_edges_move", text="Edges Only"),
-        "FACE": lambda layout: layout.operator("mesh.extrude_faces_move", text="Individual Faces"),
-        "REGION": lambda layout: layout.operator("view3d.edit_mesh_extrude_move_normal", text="Region"),
+        "VERT": lambda layout: layout.operator("mesh.extrude_vertices_move", text=_("Vertices Only")),
+        "EDGE": lambda layout: layout.operator("mesh.extrude_edges_move", text=_("Edges Only")),
+        "FACE": lambda layout: layout.operator("mesh.extrude_faces_move", text=_("Individual Faces")),
+        "REGION": lambda layout: layout.operator("view3d.edit_mesh_extrude_move_normal", text=_("Region")),
     }
 
     @staticmethod
@@ -1651,28 +1652,28 @@ class VIEW3D_MT_edit_mesh_edges(Menu):
         layout.separator()
 
         layout.operator("mesh.mark_seam")
-        layout.operator("mesh.mark_seam", text="Clear Seam").clear = True
+        layout.operator("mesh.mark_seam", text=_("Clear Seam")).clear = True
 
         layout.separator()
 
         layout.operator("mesh.mark_sharp")
-        layout.operator("mesh.mark_sharp", text="Clear Sharp").clear = True
+        layout.operator("mesh.mark_sharp", text=_("Clear Sharp")).clear = True
 
         layout.separator()
 
-        layout.operator("mesh.edge_rotate", text="Rotate Edge CW").direction = 'CW'
-        layout.operator("mesh.edge_rotate", text="Rotate Edge CCW").direction = 'CCW'
+        layout.operator("mesh.edge_rotate", text=_("Rotate Edge CW")).direction = 'CW'
+        layout.operator("mesh.edge_rotate", text=_("Rotate Edge CCW")).direction = 'CCW'
 
         layout.separator()
 
         layout.operator("TRANSFORM_OT_edge_slide")
         layout.operator("TRANSFORM_OT_edge_crease")
-        layout.operator("mesh.loop_multi_select", text="Edge Loop")
+        layout.operator("mesh.loop_multi_select", text=_("Edge Loop"))
 
         # uiItemO(layout, "Loopcut", 0, "mesh.loop_cut"); // CutEdgeloop(em, 1);
         # uiItemO(layout, "Edge Slide", 0, "mesh.edge_slide"); // EdgeSlide(em, 0,0.0);
 
-        layout.operator("mesh.loop_multi_select", text="Edge Ring").ring = True
+        layout.operator("mesh.loop_multi_select", text=_("Edge Ring")).ring = True
 
         layout.operator("mesh.loop_to_region")
         layout.operator("mesh.region_to_loop")
@@ -1716,7 +1717,7 @@ class VIEW3D_MT_edit_mesh_faces(Menu):
         # uiItemO(layout, NULL, 0, "mesh.face_mode"); // mesh_set_face_flags(em, 1);
         # uiItemBooleanO(layout, NULL, 0, "mesh.face_mode", "clear", 1); // mesh_set_face_flags(em, 0);
 
-        layout.operator("mesh.edge_rotate", text="Rotate Edge CW").direction = 'CW'
+        layout.operator("mesh.edge_rotate", text=_("Rotate Edge CW")).direction = 'CW'
 
         layout.separator()
 
@@ -1732,8 +1733,8 @@ class VIEW3D_MT_edit_mesh_normals(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("mesh.normals_make_consistent", text="Recalculate Outside")
-        layout.operator("mesh.normals_make_consistent", text="Recalculate Inside").inside = True
+        layout.operator("mesh.normals_make_consistent", text=_("Recalculate Outside"))
+        layout.operator("mesh.normals_make_consistent", text=_("Recalculate Inside")).inside = True
 
         layout.separator()
 
@@ -1763,7 +1764,7 @@ def draw_curve(self, context):
     layout.operator("curve.separate")
     layout.operator("curve.make_segment")
     layout.operator("curve.cyclic_toggle")
-    layout.operator("curve.delete", text="Delete...")
+    layout.operator("curve.delete", text=_("Delete..."))
 
     layout.separator()
 
@@ -1795,7 +1796,7 @@ class VIEW3D_MT_edit_curve_ctrlpoints(Menu):
         edit_object = context.edit_object
 
         if edit_object.type == 'CURVE':
-            layout.operator("transform.transform", text="Tilt").mode = 'TILT'
+            layout.operator("transform.transform", text=_("Tilt")).mode = 'TILT'
             layout.operator("curve.tilt_clear")
             layout.operator("curve.separate")
 
@@ -1856,10 +1857,10 @@ class VIEW3D_MT_edit_font(Menu):
 
         layout.separator()
 
-        layout.operator("font.style_toggle", text="Toggle Bold").style = 'BOLD'
-        layout.operator("font.style_toggle", text="Toggle Italic").style = 'ITALIC'
-        layout.operator("font.style_toggle", text="Toggle Underline").style = 'UNDERLINE'
-        layout.operator("font.style_toggle", text="Toggle Small Caps").style = 'SMALL_CAPS'
+        layout.operator("font.style_toggle", text=_("Toggle Bold")).style = 'BOLD'
+        layout.operator("font.style_toggle", text=_("Toggle Italic")).style = 'ITALIC'
+        layout.operator("font.style_toggle", text=_("Toggle Underline")).style = 'UNDERLINE'
+        layout.operator("font.style_toggle", text=_("Toggle Small Caps")).style = 'SMALL_CAPS'
 
 
 class VIEW3D_MT_edit_text_chars(Menu):
@@ -1916,7 +1917,7 @@ class VIEW3D_MT_edit_meta(Menu):
 
         layout.separator()
 
-        layout.operator("mball.delete_metaelems", text="Delete...")
+        layout.operator("mball.delete_metaelems", text=_("Delete..."))
         layout.operator("mball.duplicate_metaelems")
 
         layout.separator()
@@ -1935,9 +1936,9 @@ class VIEW3D_MT_edit_meta_showhide(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("mball.reveal_metaelems", text="Show Hidden")
-        layout.operator("mball.hide_metaelems", text="Hide Selected")
-        layout.operator("mball.hide_metaelems", text="Hide Unselected").unselected = True
+        layout.operator("mball.reveal_metaelems", text=_("Show Hidden"))
+        layout.operator("mball.hide_metaelems", text=_("Hide Selected"))
+        layout.operator("mball.hide_metaelems", text=_("Hide Unselected")).unselected = True
 
 
 class VIEW3D_MT_edit_lattice(Menu):
@@ -1991,15 +1992,15 @@ class VIEW3D_MT_edit_armature(Menu):
 
         layout.separator()
 
-        layout.operator("armature.subdivide", text="Subdivide")
-        layout.operator("armature.switch_direction", text="Switch Direction")
+        layout.operator("armature.subdivide", text=_("Subdivide"))
+        layout.operator("armature.switch_direction", text=_("Switch Direction"))
 
         layout.separator()
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("armature.autoside_names", text="AutoName Left/Right").type = 'XAXIS'
-        layout.operator("armature.autoside_names", text="AutoName Front/Back").type = 'YAXIS'
-        layout.operator("armature.autoside_names", text="AutoName Top/Bottom").type = 'ZAXIS'
+        layout.operator("armature.autoside_names", text=_("AutoName Left/Right")).type = 'XAXIS'
+        layout.operator("armature.autoside_names", text=_("AutoName Front/Back")).type = 'YAXIS'
+        layout.operator("armature.autoside_names", text=_("AutoName Top/Bottom")).type = 'ZAXIS'
         layout.operator("armature.flip_names")
 
         layout.separator()
@@ -2014,7 +2015,7 @@ class VIEW3D_MT_edit_armature(Menu):
 
         layout.separator()
 
-        layout.menu("VIEW3D_MT_bone_options_toggle", text="Bone Settings")
+        layout.menu("VIEW3D_MT_bone_options_toggle", text=_("Bone Settings"))
 
 
 class VIEW3D_MT_armature_specials(Menu):
@@ -2025,16 +2026,16 @@ class VIEW3D_MT_armature_specials(Menu):
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("armature.subdivide", text="Subdivide")
-        layout.operator("armature.switch_direction", text="Switch Direction")
+        layout.operator("armature.subdivide", text=_("Subdivide"))
+        layout.operator("armature.switch_direction", text=_("Switch Direction"))
 
         layout.separator()
 
         layout.operator_context = 'EXEC_REGION_WIN'
-        layout.operator("armature.autoside_names", text="AutoName Left/Right").type = 'XAXIS'
-        layout.operator("armature.autoside_names", text="AutoName Front/Back").type = 'YAXIS'
-        layout.operator("armature.autoside_names", text="AutoName Top/Bottom").type = 'ZAXIS'
-        layout.operator("armature.flip_names", text="Flip Names")
+        layout.operator("armature.autoside_names", text=_("AutoName Left/Right")).type = 'XAXIS'
+        layout.operator("armature.autoside_names", text=_("AutoName Front/Back")).type = 'YAXIS'
+        layout.operator("armature.autoside_names", text=_("AutoName Top/Bottom")).type = 'ZAXIS'
+        layout.operator("armature.flip_names", text=_("Flip Names"))
 
 
 class VIEW3D_MT_edit_armature_parent(Menu):
@@ -2043,8 +2044,8 @@ class VIEW3D_MT_edit_armature_parent(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("armature.parent_set", text="Make")
-        layout.operator("armature.parent_clear", text="Clear")
+        layout.operator("armature.parent_set", text=_("Make"))
+        layout.operator("armature.parent_clear", text=_("Clear"))
 
 
 class VIEW3D_MT_edit_armature_roll(Menu):
@@ -2057,7 +2058,7 @@ class VIEW3D_MT_edit_armature_roll(Menu):
 
         layout.separator()
 
-        layout.operator("transform.transform", text="Set Roll").mode = 'BONE_ROLL'
+        layout.operator("transform.transform", text=_("Set Roll")).mode = 'BONE_ROLL'
 
 # ********** Panel **********
 
@@ -2080,26 +2081,26 @@ class VIEW3D_PT_view3d_properties(Panel):
         col = layout.column()
         col.active = view.region_3d.view_perspective != 'CAMERA'
         col.prop(view, "lens")
-        col.label(text="Lock to Object:")
+        col.label(text=_("Lock to Object:"))
         col.prop(view, "lock_object", text="")
         lock_object = view.lock_object
         if lock_object:
             if lock_object.type == 'ARMATURE':
                 col.prop_search(view, "lock_bone", lock_object.data, "edit_bones" if lock_object.mode == 'EDIT' else "bones", text="")
         else:
-            col.prop(view, "lock_cursor", text="Lock to Cursor")
+            col.prop(view, "lock_cursor", text=_("Lock to Cursor"))
 
         col = layout.column()
         col.prop(view, "lock_camera")
 
         col = layout.column(align=True)
-        col.label(text="Clip:")
-        col.prop(view, "clip_start", text="Start")
-        col.prop(view, "clip_end", text="End")
+        col.label(text=_("Clip:"))
+        col.prop(view, "clip_start", text=_("Start"))
+        col.prop(view, "clip_end", text=_("End"))
 
         subcol = col.column()
         subcol.enabled = not view.lock_camera_and_layers
-        subcol.label(text="Local Camera:")
+        subcol.label(text=_("Local Camera:"))
         subcol.prop(view, "camera", text="")
 
         layout.column().prop(view, "cursor_location")
@@ -2165,7 +2166,7 @@ class VIEW3D_PT_view3d_display(Panel):
         col = layout.column()
         col.active = display_all
         split = col.split(percentage=0.55)
-        split.prop(view, "show_floor", text="Grid Floor")
+        split.prop(view, "show_floor", text=_("Grid Floor"))
 
         row = split.row(align=True)
         row.prop(view, "show_axis_x", text="X", toggle=True)
@@ -2174,14 +2175,14 @@ class VIEW3D_PT_view3d_display(Panel):
 
         sub = col.column(align=True)
         sub.active = (display_all and view.show_floor)
-        sub.prop(view, "grid_lines", text="Lines")
-        sub.prop(view, "grid_scale", text="Scale")
+        sub.prop(view, "grid_lines", text=_("Lines"))
+        sub.prop(view, "grid_scale", text=_("Scale"))
         subsub = sub.column(align=True)
         subsub.active = scene.unit_settings.system == 'NONE'
-        subsub.prop(view, "grid_subdivisions", text="Subdivisions")
+        subsub.prop(view, "grid_subdivisions", text=_("Subdivisions"))
 
         col = layout.column()
-        col.label(text="Shading:")
+        col.label(text=_("Shading:"))
         col.prop(gs, "material_mode", text="")
         col.prop(view, "show_textured_solid")
 
@@ -2189,7 +2190,7 @@ class VIEW3D_PT_view3d_display(Panel):
 
         region = view.region_quadview
 
-        layout.operator("screen.region_quadview", text="Toggle Quad View")
+        layout.operator("screen.region_quadview", text=_("Toggle Quad View"))
 
         if region:
             col = layout.column()
@@ -2218,22 +2219,22 @@ class VIEW3D_PT_view3d_meshdisplay(Panel):
         mesh = context.active_object.data
 
         col = layout.column()
-        col.label(text="Overlays:")
-        col.prop(mesh, "show_edges", text="Edges")
-        col.prop(mesh, "show_faces", text="Faces")
-        col.prop(mesh, "show_edge_crease", text="Creases")
-        col.prop(mesh, "show_edge_bevel_weight", text="Bevel Weights")
-        col.prop(mesh, "show_edge_seams", text="Seams")
-        col.prop(mesh, "show_edge_sharp", text="Sharp")
+        col.label(text=_("Overlays:"))
+        col.prop(mesh, "show_edges", text=_("Edges"))
+        col.prop(mesh, "show_faces", text=_("Faces"))
+        col.prop(mesh, "show_edge_crease", text=_("Creases"))
+        col.prop(mesh, "show_edge_bevel_weight", text=_("Bevel Weights"))
+        col.prop(mesh, "show_edge_seams", text=_("Seams"))
+        col.prop(mesh, "show_edge_sharp", text=_("Sharp"))
 
         col.separator()
-        col.label(text="Normals:")
-        col.prop(mesh, "show_normal_face", text="Face")
-        col.prop(mesh, "show_normal_vertex", text="Vertex")
-        col.prop(context.scene.tool_settings, "normal_size", text="Normal Size")
+        col.label(text=_("Normals:"))
+        col.prop(mesh, "show_normal_face", text=_("Face"))
+        col.prop(mesh, "show_normal_vertex", text=_("Vertex"))
+        col.prop(context.scene.tool_settings, "normal_size", text=_("Normal Size"))
 
         col.separator()
-        col.label(text="Numerics:")
+        col.label(text=_("Numerics:"))
         col.prop(mesh, "show_extra_edge_length")
         col.prop(mesh, "show_extra_face_angle")
         col.prop(mesh, "show_extra_face_area")
@@ -2255,10 +2256,10 @@ class VIEW3D_PT_view3d_curvedisplay(Panel):
         curve = context.active_object.data
 
         col = layout.column()
-        col.label(text="Overlays:")
-        col.prop(curve, "show_handles", text="Handles")
-        col.prop(curve, "show_normal_face", text="Normals")
-        col.prop(context.scene.tool_settings, "normal_size", text="Normal Size")
+        col.label(text=_("Overlays:"))
+        col.prop(curve, "show_handles", text=_("Handles"))
+        col.prop(curve, "show_normal_face", text=_("Normals"))
+        col.prop(context.scene.tool_settings, "normal_size", text=_("Normal Size"))
 
 
 class VIEW3D_PT_background_image(Panel):
@@ -2285,7 +2286,7 @@ class VIEW3D_PT_background_image(Panel):
         view = context.space_data
 
         col = layout.column()
-        col.operator("view3d.background_image_add", text="Add Image")
+        col.operator("view3d.background_image_add", text=_("Add Image"))
 
         for i, bg in enumerate(view.background_images):
             layout.active = view.show_background_images
@@ -2295,10 +2296,10 @@ class VIEW3D_PT_background_image(Panel):
             if bg.image:
                 row.prop(bg.image, "name", text="", emboss=False)
             else:
-                row.label(text="Not Set")
+                row.label(text=_("Not Set"))
             row.operator("view3d.background_image_remove", text="", emboss=False, icon='X').index = i
 
-            box.prop(bg, "view_axis", text="Axis")
+            box.prop(bg, "view_axis", text=_("Axis"))
 
             if bg.show_expanded:
                 row = box.row()
@@ -2333,13 +2334,13 @@ class VIEW3D_PT_transform_orientations(Panel):
         col = layout.column()
 
         col.prop(view, "transform_orientation")
-        col.operator("transform.create_orientation", text="Create")
+        col.operator("transform.create_orientation", text=_("Create"))
 
         orientation = view.current_orientation
 
         if orientation:
             col.prop(orientation, "name")
-            col.operator("transform.delete_orientation", text="Delete")
+            col.operator("transform.delete_orientation", text=_("Delete"))
 
 
 class VIEW3D_PT_etch_a_ton(Panel):
@@ -2384,7 +2385,7 @@ class VIEW3D_PT_etch_a_ton(Panel):
             col.prop(toolsettings, "etch_number")
             col.prop(toolsettings, "etch_side")
 
-        col.operator("sketch.convert", text="Convert")
+        col.operator("sketch.convert", text=_("Convert"))
 
 
 class VIEW3D_PT_context_properties(Panel):
diff --git a/release/scripts/startup/bl_ui/space_view3d_toolbar.py b/release/scripts/startup/bl_ui/space_view3d_toolbar.py
index e322a6dcd13..6bd2168dab9 100644
--- a/release/scripts/startup/bl_ui/space_view3d_toolbar.py
+++ b/release/scripts/startup/bl_ui/space_view3d_toolbar.py
@@ -19,6 +19,7 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Menu, Panel
+from blf import gettext as _
 
 
 class View3DPanel():
@@ -31,33 +32,33 @@ class View3DPanel():
 # History/Repeat tools
 def draw_repeat_tools(context, layout):
     col = layout.column(align=True)
-    col.label(text="Repeat:")
+    col.label(text=_("Repeat:"))
     col.operator("screen.repeat_last")
-    col.operator("screen.repeat_history", text="History...")
+    col.operator("screen.repeat_history", text=_("History..."))
 
 
 # Keyframing tools
 def draw_keyframing_tools(context, layout):
     col = layout.column(align=True)
-    col.label(text="Keyframes:")
+    col.label(text=_("Keyframes:"))
     row = col.row()
-    row.operator("anim.keyframe_insert_menu", text="Insert")
-    row.operator("anim.keyframe_delete_v3d", text="Remove")
+    row.operator("anim.keyframe_insert_menu", text=_("Insert"))
+    row.operator("anim.keyframe_delete_v3d", text=_("Remove"))
 
 
 # Grease Pencil tools
 def draw_gpencil_tools(context, layout):
     col = layout.column(align=True)
 
-    col.label(text="Grease Pencil:")
+    col.label(text=_("Grease Pencil:"))
 
     row = col.row()
-    row.operator("gpencil.draw", text="Draw").mode = 'DRAW'
-    row.operator("gpencil.draw", text="Line").mode = 'DRAW_STRAIGHT'
+    row.operator("gpencil.draw", text=_("Draw")).mode = 'DRAW'
+    row.operator("gpencil.draw", text=_("Line")).mode = 'DRAW_STRAIGHT'
 
     row = col.row()
-    row.operator("gpencil.draw", text="Poly").mode = 'DRAW_POLY'
-    row.operator("gpencil.draw", text="Erase").mode = 'ERASER'
+    row.operator("gpencil.draw", text=_("Poly")).mode = 'DRAW_POLY'
+    row.operator("gpencil.draw", text=_("Erase")).mode = 'ERASER'
 
     row = col.row()
     row.prop(context.tool_settings, "use_grease_pencil_sessions")
@@ -73,16 +74,16 @@ class VIEW3D_PT_tools_objectmode(View3DPanel, Panel):
         layout = self.layout
 
         col = layout.column(align=True)
-        col.label(text="Transform:")
+        col.label(text=_("Transform:"))
         col.operator("transform.translate")
         col.operator("transform.rotate")
-        col.operator("transform.resize", text="Scale")
+        col.operator("transform.resize", text=_("Scale"))
 
         col = layout.column(align=True)
-        col.operator("object.origin_set", text="Origin")
+        col.operator("object.origin_set", text=_("Origin"))
 
         col = layout.column(align=True)
-        col.label(text="Object:")
+        col.label(text=_("Object:"))
         col.operator("object.duplicate_move")
         col.operator("object.delete")
         col.operator("object.join")
@@ -91,17 +92,17 @@ class VIEW3D_PT_tools_objectmode(View3DPanel, Panel):
         if active_object and active_object.type == 'MESH':
 
             col = layout.column(align=True)
-            col.label(text="Shading:")
+            col.label(text=_("Shading:"))
             row = col.row(align=True)
-            row.operator("object.shade_smooth", text="Smooth")
-            row.operator("object.shade_flat", text="Flat")
+            row.operator("object.shade_smooth", text=_("Smooth"))
+            row.operator("object.shade_flat", text=_("Flat"))
 
         draw_keyframing_tools(context, layout)
 
         col = layout.column(align=True)
-        col.label(text="Motion Paths:")
-        col.operator("object.paths_calculate", text="Calculate Paths")
-        col.operator("object.paths_clear", text="Clear Paths")
+        col.label(text=_("Motion Paths:"))
+        col.operator("object.paths_calculate", text=_("Calculate Paths"))
+        col.operator("object.paths_clear", text=_("Clear Paths"))
 
         draw_repeat_tools(context, layout)
 
@@ -122,8 +123,8 @@ class VIEW3D_PT_tools_meshedit(View3DPanel, Panel):
         col.operator("transform.translate")
         col.operator("transform.rotate")
         col.operator("transform.resize", text="Scale")
-        col.operator("transform.shrink_fatten", text="Shrink/Fatten")
-        col.operator("transform.push_pull", text="Push/Pull")
+        col.operator("transform.shrink_fatten", text=_("Shrink/Fatten"))
+        col.operator("transform.push_pull", text=_("Push/Pull"))
 
         col = layout.column(align=True)
         col.label(text="Deform:")
@@ -1016,7 +1017,7 @@ class VIEW3D_PT_tools_brush_appearance(PaintPanel, Panel):
         brush = settings.brush
 
         if brush is None:  # unlikely but can happen
-            layout.label(text="Brush Unset")
+            layout.label(text=_("Brush Unset"))
             return
 
         col = layout.column()
diff --git a/source/blender/blenfont/BLF_api.h b/source/blender/blenfont/BLF_api.h
index 00943ace05c..1bb61d02b78 100644
--- a/source/blender/blenfont/BLF_api.h
+++ b/source/blender/blenfont/BLF_api.h
@@ -178,20 +178,6 @@ void BLF_buffer_col(int fontid, float r, float g, float b, float a);
  */
 void BLF_draw_buffer(int fontid, const char *str);
 
-/*
- * Search the path directory to the locale files, this try all
- * the case for Linux, Win and Mac.
- */
-void BLF_lang_init(void);
-
-/* Set the current locale. */
-void BLF_lang_set(const char *);
-
-/* Set the current encoding name. */
-void BLF_lang_encoding_name(const char *str);
-
-void BLF_lang_encoding(const char *str);
-
 /* Add a path to the font dir paths. */
 void BLF_dir_add(const char *path);
 
diff --git a/source/blender/blenfont/BLF_translation.h b/source/blender/blenfont/BLF_translation.h
new file mode 100644
index 00000000000..4377d391354
--- /dev/null
+++ b/source/blender/blenfont/BLF_translation.h
@@ -0,0 +1,66 @@
+/*
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2011 Blender Foundation.
+ * All rights reserved.
+ *
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/blenfont/BLF_translation.h
+ *  \ingroup blf
+ */
+
+
+#ifndef BLF_TRANSLATION_H
+#define BLF_TRANSLATION_H
+
+/* blf_translation.c  */
+
+#ifdef INTERNATIONAL
+unsigned char *BLF_get_unifont(int *unifont_size);
+void BLF_free_unifont(void);
+#endif
+
+const char* BLF_gettext(const char *msgid);
+
+/* blf_lang.c */
+
+/*
+ * Search the path directory to the locale files, this try all
+ * the case for Linux, Win and Mac.
+ */
+void BLF_lang_init(void);
+
+/* Set the current locale. */
+void BLF_lang_set(const char *);
+
+/* Set the current encoding name. */
+void BLF_lang_encoding_name(const char *str);
+
+void BLF_lang_encoding(const char *str);
+
+#define _(msgid) BLF_gettext(msgid)
+#define N_(msgid) msgid
+
+#endif /* BLF_TRANSLATION_H */
diff --git a/source/blender/blenfont/CMakeLists.txt b/source/blender/blenfont/CMakeLists.txt
index 82099d4f125..b87a3b88f07 100644
--- a/source/blender/blenfont/CMakeLists.txt
+++ b/source/blender/blenfont/CMakeLists.txt
@@ -42,9 +42,11 @@ set(SRC
 	intern/blf_font.c
 	intern/blf_glyph.c
 	intern/blf_lang.c
+	intern/blf_translation.c
 	intern/blf_util.c
 
 	BLF_api.h
+	BLF_translation.h
 	intern/blf_internal.h
 	intern/blf_internal_types.h
 )
@@ -56,9 +58,5 @@ if(WITH_INTERNATIONAL)
 	add_definitions(-DINTERNATIONAL)
 endif()
 
-if(WIN32 AND NOT UNIX)
-	add_definitions(-DUSE_GETTEXT_DLL)
-endif()
-
 blender_add_lib(bf_blenfont "${SRC}" "${INC}" "${INC_SYS}")
 
diff --git a/source/blender/blenfont/SConscript b/source/blender/blenfont/SConscript
index 2763bea0da0..45a55793856 100644
--- a/source/blender/blenfont/SConscript
+++ b/source/blender/blenfont/SConscript
@@ -13,7 +13,6 @@ defs = []
 
 if sys.platform == 'win32' or env['OURPLATFORM'] == 'linuxcross':
     defs.append('_WIN32')
-    defs.append('USE_GETTEXT_DLL')
 
 if env['WITH_BF_INTERNATIONAL']:
     defs.append('INTERNATIONAL')
diff --git a/source/blender/blenfont/intern/blf_lang.c b/source/blender/blenfont/intern/blf_lang.c
index 80951899040..8f745180b8b 100644
--- a/source/blender/blenfont/intern/blf_lang.c
+++ b/source/blender/blenfont/intern/blf_lang.c
@@ -39,8 +39,14 @@
 #ifdef INTERNATIONAL
 
 #include <locale.h>
+
+#if defined (_WIN32)
+#include <windows.h>
+#endif
+
 #include "libintl.h"
 
+#include "DNA_userdef_types.h"
 
 #include "DNA_listBase.h"
 #include "DNA_vec_types.h"
@@ -60,6 +66,35 @@ static char global_messagepath[1024];
 static char global_language[32];
 static char global_encoding_name[32];
 
+/* map from the rna_userdef.c:rna_def_userdef_system(BlenderRNA *brna):language_items */
+static const char *locales[] = {
+	"", "",
+	"english", "en_US",
+	"japanese", "ja_JP",
+	"dutch", "nl_NL",
+	"italian", "it_IT",
+	"german", "de_DE",
+	"finnish", "fi_FI",
+	"swedish", "sv_SE",
+	"french", "fr_FR",
+	"spanish", "es_ES",
+	"catalan", "ca_AD",
+	"czech", "cs_CZ",
+	"ptb", "pt_BR",
+	"chs", "zh_CN",
+	"cht", "zh_TW",
+	"russian", "ru_RU",
+	"croatian", "hr_HR",
+	"serbian", "sr_RS",
+	"ukrainian", "uk_UA",
+	"polish", "pl_PL",
+	"romanian", "ro_RO",
+	"arabic", "ar_EG",
+	"bulgarian", "bg_BG",
+	"greek", "el_GR",
+	"korean", "ko_KR",
+	"nepali", "ne_NP",
+};
 
 void BLF_lang_init(void)
 {
@@ -77,34 +112,95 @@ void BLF_lang_init(void)
 /* XXX WARNING!!! IN osx somehow the previous function call jumps in this one??? (ton, ppc) */
 void BLF_lang_set(const char *str)
 {
-	if(str==NULL) {
+	char *locreturn;
+	const char *short_locale;
+	int ok= 1;
+#if defined (_WIN32)
+	char *long_locale = locales[ 2 * U.language];
+#endif
+
+	if((U.transopts&USER_DOTRANSLATE)==0)
 		return;
+
+	if(str)
+		short_locale = str;
+	else
+		short_locale = locales[ 2 * U.language + 1];
+
+#if defined (_WIN32)
+	if(short_locale) {
+		char *envStr;
+
+		if( U.language==0 )/* use system setting */
+			envStr = BLI_sprintfN( "LANG=%s", getenv("LANG") );
+		else
+			envStr = BLI_sprintfN( "LANG=%s", short_locale );
+
+		gettext_putenv(envStr);
+		MEM_freeN(envStr);
+	}
+
+	locreturn= setlocale(LC_ALL, long_locale);
+
+	if (locreturn == NULL) {
+		printf("Could not change locale to %s\n", long_locale);
+		ok= 0;
 	}
-	else {
-	
-#if defined (_WIN32) || defined(__APPLE__)
-		BLI_setenv("LANG", str);
 #else
-		char *locreturn= setlocale(LC_ALL, str);
+	{
+		const char *locale;
+		static char default_locale[64]="\0";
+
+		if(default_locale[0]==0) {
+			char *env_language= getenv("LANGUAGE");
+
+			if(env_language) {
+				char *s;
+
+				/* store defaul locale */
+				strncpy(default_locale, env_language, sizeof(default_locale));
+
+				/* use first language as default */
+				s= strchr(default_locale, ':');
+				if(s) s[0]= 0;
+			}
+		}
+
+		if(short_locale[0])
+			locale= short_locale;
+		else
+			locale= default_locale;
+
+		BLI_setenv("LANG", locale);
+		BLI_setenv("LANGUAGE", locale);
+
+		locreturn= setlocale(LC_ALL, locale);
+
 		if (locreturn == NULL) {
-			char *lang= BLI_sprintfN("%s.UTF-8", str);
+			char *short_locale_utf8= BLI_sprintfN("%s.UTF-8", short_locale);
+
+			locreturn= setlocale(LC_ALL, short_locale_utf8);
 
-			locreturn= setlocale(LC_ALL, lang);
 			if (locreturn == NULL) {
-				printf("could not change language to %s nor %s\n", str, lang);
+				printf("Could not change locale to %s nor %s\n", short_locale, short_locale_utf8);
+				ok= 0;
 			}
 
-			MEM_freeN(lang);
+			MEM_freeN(short_locale_utf8);
 		}
-
-		setlocale(LC_NUMERIC, "C");
+	}
 #endif
-		textdomain(DOMAIN_NAME);
-		bindtextdomain(DOMAIN_NAME, global_messagepath);
-		/* bind_textdomain_codeset(DOMAIN_NAME, global_encoding_name); */
-		BLI_strncpy(global_language, str, sizeof(global_language));
-		
+
+	if(ok) {
+		//printf("Change locale to %s\n", locreturn );
+		BLI_strncpy(global_language, locreturn, sizeof(global_language));
 	}
+
+	setlocale(LC_NUMERIC, "C");
+
+	textdomain(DOMAIN_NAME);
+	bindtextdomain(DOMAIN_NAME, global_messagepath);
+	bind_textdomain_codeset(DOMAIN_NAME, global_encoding_name);
 }
 
 void BLF_lang_encoding(const char *str)
diff --git a/source/blender/blenfont/intern/blf_translation.c b/source/blender/blenfont/intern/blf_translation.c
new file mode 100644
index 00000000000..b53f4cf7609
--- /dev/null
+++ b/source/blender/blenfont/intern/blf_translation.c
@@ -0,0 +1,86 @@
+/*
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2011 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation,
+ *                 Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/blenfont/intern/blf_translation.c
+ *  \ingroup blf
+ */
+
+#include <stdlib.h>
+
+#ifdef INTERNATIONAL
+#include <libintl.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_path_util.h"
+#include "BLI_string.h"
+#include "BLI_path_util.h"
+#include "BLI_fileops.h"
+
+#include "BLF_translation.h"
+
+#ifdef INTERNATIONAL
+const char unifont_filename[]="droidsans.ttf.gz";
+static unsigned char *unifont_ttf= NULL;
+static int unifont_size= 0;
+
+unsigned char *BLF_get_unifont(int *unifont_size_r)
+{
+	if(unifont_ttf==NULL) {
+		char *fontpath = BLI_get_folder(BLENDER_DATAFILES, "fonts");
+		char unifont_path[1024];
+
+		BLI_snprintf(unifont_path, sizeof(unifont_path), "%s/%s", fontpath, unifont_filename);
+
+		unifont_ttf= (unsigned char*)BLI_ungzip_to_mem(unifont_path, &unifont_size);
+	}
+
+	*unifont_size_r= unifont_size;
+
+	return unifont_ttf;
+}
+
+void BLF_free_unifont(void)
+{
+	if(unifont_ttf)
+		MEM_freeN(unifont_ttf);
+}
+
+#endif
+
+const char* BLF_gettext(const char *msgid)
+{
+#ifdef INTERNATIONAL
+	if( msgid[0] )
+		return gettext( msgid );
+	return "";
+#else
+	return msgid;
+#endif
+}
diff --git a/source/blender/blenlib/BLI_fileops.h b/source/blender/blenlib/BLI_fileops.h
index 59c01348c07..21d28ca3185 100644
--- a/source/blender/blenlib/BLI_fileops.h
+++ b/source/blender/blenlib/BLI_fileops.h
@@ -53,6 +53,7 @@ int   BLI_exists(const char *file);
 int   BLI_copy_fileops(const char *file, const char *to);
 int   BLI_rename(const char *from, const char *to);
 int   BLI_gzip(const char *from, const char *to);
+char *BLI_ungzip_to_mem(const char *from_file, int *size_r);
 int   BLI_delete(const char *file, int dir, int recursive);
 int   BLI_move(const char *file, const char *to);
 int   BLI_touch(const char *file);
diff --git a/source/blender/blenlib/intern/fileops.c b/source/blender/blenlib/intern/fileops.c
index 3299752646b..6b125435b31 100644
--- a/source/blender/blenlib/intern/fileops.c
+++ b/source/blender/blenlib/intern/fileops.c
@@ -52,6 +52,8 @@
 #include <sys/param.h>
 #endif
 
+#include "MEM_guardedalloc.h"
+
 #include "BLI_blenlib.h"
 
 #include "BKE_utildefines.h"
@@ -104,6 +106,45 @@ int BLI_gzip(const char *from, const char *to) {
 	return rval;
 }
 
+/* gzip the file in from_file and write it to memery to_mem, at most size bytes.
+   return the unziped size
+  */
+char *BLI_ungzip_to_mem(const char *from_file, int *size_r)
+{
+	gzFile gzfile;
+	int readsize, size, alloc_size=0;
+	char *mem= NULL;
+	const int chunk_size= 512*1024;
+
+	size= 0;
+
+	gzfile = gzopen( from_file, "rb" );
+
+	for(;;) {
+		if(mem==NULL) {
+			mem= MEM_callocN(chunk_size, "BLI_ungzip_to_mem");
+			alloc_size= chunk_size;
+		} else {
+			mem= MEM_reallocN(mem, size+chunk_size);
+			alloc_size+= chunk_size;
+		}
+
+		readsize= gzread(gzfile, mem+size, chunk_size);
+		if(readsize>0) {
+			size+= readsize;
+		}
+		else break;
+	}
+
+	if(mem && alloc_size!=size)
+		mem= MEM_reallocN(mem, size);
+
+	*size_r= size;
+
+	return mem;
+}
+
+
 /* return 1 when file can be written */
 int BLI_is_writable(const char *filename)
 {
diff --git a/source/blender/editors/armature/CMakeLists.txt b/source/blender/editors/armature/CMakeLists.txt
index 9a44525611a..7ecbdc9ebe5 100644
--- a/source/blender/editors/armature/CMakeLists.txt
+++ b/source/blender/editors/armature/CMakeLists.txt
@@ -21,6 +21,7 @@
 
 set(INC
 	../include
+	../../blenfont
 	../../blenkernel
 	../../blenlib
 	../../blenloader
diff --git a/source/blender/editors/armature/SConscript b/source/blender/editors/armature/SConscript
index b7f9a263bc1..ded82b3dfb7 100644
--- a/source/blender/editors/armature/SConscript
+++ b/source/blender/editors/armature/SConscript
@@ -3,7 +3,7 @@ Import ('env')
 
 sources = env.Glob('*.c')
 
-incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf ../../blenloader'
+incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../imbuf ../../blenloader'
 incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
 incs += ' ../../gpu ../../makesrna #/intern/opennl/extern'
 
diff --git a/source/blender/editors/armature/poselib.c b/source/blender/editors/armature/poselib.c
index 67c93c4c906..8a7d837d2a8 100644
--- a/source/blender/editors/armature/poselib.c
+++ b/source/blender/editors/armature/poselib.c
@@ -43,6 +43,8 @@
 #include "BLI_dlrbTree.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "DNA_anim_types.h"
 #include "DNA_armature_types.h"
 #include "DNA_object_types.h"
@@ -407,15 +409,15 @@ static int poselib_add_menu_invoke (bContext *C, wmOperator *op, wmEvent *UNUSED
 	uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
 	
 	/* add new (adds to the first unoccupied frame) */
-	uiItemIntO(layout, "Add New", ICON_NONE, "POSELIB_OT_pose_add", "frame", poselib_get_free_index(ob->poselib));
+	uiItemIntO(layout, UI_translate_do_iface(N_("Add New")), ICON_NONE, "POSELIB_OT_pose_add", "frame", poselib_get_free_index(ob->poselib));
 	
 	/* check if we have any choices to add a new pose in any other way */
 	if ((ob->poselib) && (ob->poselib->markers.first)) {
 		/* add new (on current frame) */
-		uiItemIntO(layout, "Add New (Current Frame)", ICON_NONE, "POSELIB_OT_pose_add", "frame", CFRA);
+		uiItemIntO(layout, UI_translate_do_iface(N_("Add New (Current Frame)")), ICON_NONE, "POSELIB_OT_pose_add", "frame", CFRA);
 		
 		/* replace existing - submenu */
-		uiItemMenuF(layout, "Replace Existing...", 0, poselib_add_menu_invoke__replacemenu, NULL);
+		uiItemMenuF(layout, UI_translate_do_iface(N_("Replace Existing...")), 0, poselib_add_menu_invoke__replacemenu, NULL);
 	}
 	
 	uiPupMenuEnd(C, pup);
diff --git a/source/blender/editors/include/UI_interface.h b/source/blender/editors/include/UI_interface.h
index 637940f59a6..06b44e36b69 100644
--- a/source/blender/editors/include/UI_interface.h
+++ b/source/blender/editors/include/UI_interface.h
@@ -799,9 +799,15 @@ void uiStyleFontDrawRotated(struct uiFontStyle *fs, struct rcti *rect, const cha
 int UI_GetStringWidth(const char *str); // XXX temp
 void UI_DrawString(float x, float y, const char *str); // XXX temp
 void UI_DrawTriIcon(float x, float y, char dir);
-
+uiStyle* UI_GetStyle(void);
 /* linker workaround ack! */
 void UI_template_fix_linking(void);
 
+/* translation */
+int UI_translate_iface(void);
+int UI_translate_tooltips(void);
+const char *UI_translate_do_iface(const char *msgid);
+const char *UI_translate_do_tooltip(const char *msgid);
+
 #endif /*  UI_INTERFACE_H */
 
diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c
index abc668d72dd..2ff77d255c6 100644
--- a/source/blender/editors/interface/interface.c
+++ b/source/blender/editors/interface/interface.c
@@ -55,6 +55,7 @@
 #include "BIF_gl.h"
 
 #include "BLF_api.h"
+#include "BLF_translation.h"
 
 #include "UI_interface.h"
 
@@ -93,19 +94,46 @@ static void ui_free_but(const bContext *C, uiBut *but);
 
 /* ************* translation ************** */
 
-int ui_translate_buttons(void)
+int UI_translate_iface(void)
 {
-	return (U.transopts & USER_TR_BUTTONS);
+#ifdef INTERNATIONAL
+	return (U.transopts & USER_DOTRANSLATE) && (U.transopts & USER_TR_IFACE);
+#else
+	return 0;
+#endif
 }
 
-int ui_translate_menus(void)
+int UI_translate_tooltips(void)
 {
-	return (U.transopts & USER_TR_MENUS);
+#ifdef INTERNATIONAL
+	return (U.transopts & USER_DOTRANSLATE) && (U.transopts & USER_TR_TOOLTIPS);
+#else
+	return 0;
+#endif
 }
 
-int ui_translate_tooltips(void)
+const char *UI_translate_do_iface(const char *msgid)
 {
-	return (U.transopts & USER_TR_TOOLTIPS);
+#ifdef INTERNATIONAL
+	if(UI_translate_iface())
+		return BLF_gettext(msgid);
+	else
+		return msgid;
+#else
+	return msgid;
+#endif
+}
+
+const char *UI_translate_do_tooltip(const char *msgid)
+{
+#ifdef INTERNATIONAL
+	if(UI_translate_tooltips())
+		return BLF_gettext(msgid);
+	else
+		return msgid;
+#else
+	return msgid;
+#endif
 }
 
 /* ************* window matrix ************** */
@@ -229,7 +257,7 @@ void ui_block_translate(uiBlock *block, int x, int y)
 
 static void ui_text_bounds_block(uiBlock *block, float offset)
 {
-	uiStyle *style= U.uistyles.first;	// XXX pass on as arg
+	uiStyle *style=UI_GetStyle();
 	uiBut *bt;
 	int i = 0, j, x1addval= offset, nextcol;
 	int lastcol= 0, col= 0;
@@ -238,9 +266,6 @@ static void ui_text_bounds_block(uiBlock *block, float offset)
 	
 	for(bt= block->buttons.first; bt; bt= bt->next) {
 		if(bt->type!=SEPR) {
-			//int transopts= ui_translate_buttons();
-			//if(bt->type==TEX || bt->type==IDPOIN) transopts= 0;
-			
 			j= BLF_width(style->widget.uifont_id, bt->drawstr);
 
 			if(j > i) i = j;
@@ -930,7 +955,7 @@ static void ui_but_to_pixelrect(rcti *rect, const ARegion *ar, uiBlock *block, u
 /* uses local copy of style, to scale things down, and allow widgets to change stuff */
 void uiDrawBlock(const bContext *C, uiBlock *block)
 {
-	uiStyle style= *((uiStyle *)U.uistyles.first);	// XXX pass on as arg
+	uiStyle style= *UI_GetStyle();	// XXX pass on as arg
 	ARegion *ar;
 	uiBut *but;
 	rcti rect;
@@ -2033,12 +2058,9 @@ void ui_check_but(uiBut *but)
 	/* if something changed in the button */
 	double value= UI_BUT_VALUE_UNSET;
 //	float okwidth; // UNUSED
-//	int transopts= ui_translate_buttons();
 	
 	ui_is_but_sel(but, &value);
 	
-//	if(but->type==TEX || but->type==IDPOIN) transopts= 0;
-
 	/* only update soft range while not editing */
 	if(but->rnaprop && !(but->editval || but->editstr || but->editvec)) {
 		UI_GET_BUT_VALUE_INIT(but, value)
@@ -2547,7 +2569,7 @@ static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *s
 			DynStr *dynstr;
 			int i, totitem, value, free;
 
-			RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free);
+			RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
 			value= RNA_property_enum_get(ptr, prop);
 
 			dynstr= BLI_dynstr_new();
@@ -2582,7 +2604,7 @@ static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *s
 			EnumPropertyItem *item;
 			int i, totitem, free;
 
-			RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free);
+			RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
 			for(i=0; i<totitem; i++) {
 				if(item[i].identifier[0] && item[i].value == (int)max) {
 					str= item[i].name;
@@ -2710,6 +2732,11 @@ static uiBut *ui_def_but_operator(uiBlock *block, int type, const char *opname,
 	
 	if ((!tip || tip[0]=='\0') && ot && ot->description) {
 		tip= ot->description;
+
+#ifdef INTERNATIONAL
+		if(UI_translate_tooltips())
+			tip= BLF_gettext(tip);
+#endif
 	}
 
 	but= ui_def_but(block, type, -1, str, x1, y1, x2, y2, NULL, 0, 0, 0, 0, tip);
diff --git a/source/blender/editors/interface/interface_handlers.c b/source/blender/editors/interface/interface_handlers.c
index 7661fa5994b..125928c136b 100644
--- a/source/blender/editors/interface/interface_handlers.c
+++ b/source/blender/editors/interface/interface_handlers.c
@@ -1269,7 +1269,7 @@ static int ui_textedit_delete_selection(uiBut *but, uiHandleButtonData *data)
 /* note, but->block->aspect is used here, when drawing button style is getting scaled too */
 static void ui_textedit_set_cursor_pos(uiBut *but, uiHandleButtonData *data, short x)
 {
-	uiStyle *style= U.uistyles.first;	// XXX pass on as arg
+	uiStyle *style= UI_GetStyle();	// XXX pass on as arg
 	uiFontStyle *fstyle = &style->widget;
 	int startx= but->x1;
 	char *origstr;
@@ -4101,7 +4101,7 @@ static uiBlock *menu_change_shortcut(bContext *C, ARegion *ar, void *arg)
 	wmKeyMapItem *kmi;
 	PointerRNA ptr;
 	uiLayout *layout;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	IDProperty *prop= (but->opptr)? but->opptr->data: NULL;
 	int kmi_id = WM_key_event_operator_id(C, but->optype->idname, but->opcontext, prop, 1, &km);
 
@@ -4133,7 +4133,7 @@ static uiBlock *menu_add_shortcut(bContext *C, ARegion *ar, void *arg)
 	wmKeyMapItem *kmi;
 	PointerRNA ptr;
 	uiLayout *layout;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	IDProperty *prop= (but->opptr)? but->opptr->data: NULL;
 	int kmi_id;
 	
diff --git a/source/blender/editors/interface/interface_intern.h b/source/blender/editors/interface/interface_intern.h
index ebc8725ad5d..72eb869dea0 100644
--- a/source/blender/editors/interface/interface_intern.h
+++ b/source/blender/editors/interface/interface_intern.h
@@ -347,10 +347,6 @@ typedef struct uiSafetyRct {
 
 extern void ui_delete_linkline(uiLinkLine *line, uiBut *but);
 
-extern int ui_translate_buttons(void);
-extern int ui_translate_menus(void);
-extern int ui_translate_tooltips(void);
-
 void ui_fontscale(short *points, float aspect);
 
 extern void ui_block_to_window_fl(const struct ARegion *ar, uiBlock *block, float *x, float *y);
diff --git a/source/blender/editors/interface/interface_layout.c b/source/blender/editors/interface/interface_layout.c
index 10300cee9ea..3c02f7d4bd2 100644
--- a/source/blender/editors/interface/interface_layout.c
+++ b/source/blender/editors/interface/interface_layout.c
@@ -43,6 +43,8 @@
 #include "BLI_string.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_global.h"
 #include "BKE_idprop.h"
@@ -475,7 +477,7 @@ static void ui_item_enum_expand(uiLayout *layout, uiBlock *block, PointerRNA *pt
 	const char *name;
 	int a, totitem, itemw, icon, value, free;
 
-	RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free);
+	RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
 
 	uiBlockSetCurLayout(block, ui_item_local_sublayout(layout, layout, 1));
 	for(a=0; a<totitem; a++) {
@@ -634,8 +636,14 @@ PointerRNA uiItemFullO(uiLayout *layout, const char *opname, const char *name, i
 		return PointerRNA_NULL;
 	}
 
-	if(!name)
+	if(!name) {
 		name= ot->name;
+
+#ifdef INTERNATIONAL
+		name= UI_translate_do_iface(name);
+#endif
+	}
+
 	if(layout->root->type == UI_LAYOUT_MENU && !icon)
 		icon= ICON_BLANK1;
 
@@ -701,7 +709,7 @@ static const char *ui_menu_enumpropname(uiLayout *layout, const char *opname, co
 		int totitem, free;
 		const char *name;
 
-		RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, &totitem, &free);
+		RNA_property_enum_items_gettexted(layout->root->block->evil_C, &ptr, prop, &item, &totitem, &free);
 		if(RNA_enum_name(item, retval, &name)) {
 			if(free) MEM_freeN(item);
 			return name;
@@ -753,7 +761,7 @@ void uiItemsFullEnumO(uiLayout *layout, const char *opname, const char *propname
 		uiLayout *split= uiLayoutSplit(layout, 0, 0);
 		uiLayout *column= uiLayoutColumn(split, 0);
 
-		RNA_property_enum_items(block->evil_C, &ptr, prop, &item, &totitem, &free);
+		RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item, &totitem, &free);
 
 		for(i=0; i<totitem; i++) {
 			if(item[i].identifier[0]) {
@@ -841,7 +849,7 @@ void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char
 	
 	/* enum lookup */
 	if((prop= RNA_struct_find_property(&ptr, propname))) {
-		RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free);
+		RNA_property_enum_items_gettexted(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free);
 		if(item==NULL || RNA_enum_value_from_id(item, value_str, &value)==0) {
 			if(free) MEM_freeN(item);
 			RNA_warning("%s.%s, enum %s not found", RNA_struct_identifier(ptr.type), propname, value_str);
@@ -1091,7 +1099,7 @@ void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *pr
 		return;
 	}
 
-	RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
+	RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item, NULL, &free);
 
 	if(!RNA_enum_value_from_id(item, value, &ivalue)) {
 		if(free) MEM_freeN(item);
@@ -1135,7 +1143,7 @@ void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname
 		uiLayout *split= uiLayoutSplit(layout, 0, 0);
 		uiLayout *column= uiLayoutColumn(split, 0);
 
-		RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free);
+		RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free);
 
 		for(i=0; i<totitem; i++) {
 			if(item[i].identifier[0]) {
@@ -1421,8 +1429,14 @@ void uiItemM(uiLayout *layout, bContext *UNUSED(C), const char *menuname, const
 		return;
 	}
 
-	if(!name)
+	if(!name) {
 		name= mt->label;
+
+#ifdef INTERNATIONAL
+		name= UI_translate_do_iface(name);
+#endif
+	}
+
 	if(layout->root->type == UI_LAYOUT_MENU && !icon)
 		icon= ICON_BLANK1;
 
@@ -2794,7 +2808,7 @@ void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,in
 		empty= uiDefAutoButsRNA(layout, &ptr, check_prop, label_align) == 0;
 
 		if(empty && (flag & UI_LAYOUT_OP_SHOW_EMPTY)) {
-			uiItemL(layout, "No Properties", ICON_NONE);
+			uiItemL(layout, UI_translate_do_iface(N_("No Properties")), ICON_NONE);
 		}
 	}
 	
diff --git a/source/blender/editors/interface/interface_panel.c b/source/blender/editors/interface/interface_panel.c
index cd1d250d6a4..ec7456eebdc 100644
--- a/source/blender/editors/interface/interface_panel.c
+++ b/source/blender/editors/interface/interface_panel.c
@@ -173,7 +173,7 @@ static void ui_panel_copy_offset(Panel *pa, Panel *papar)
 
 Panel *uiBeginPanel(ScrArea *sa, ARegion *ar, uiBlock *block, PanelType *pt, int *open)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	Panel *pa, *patab, *palast, *panext;
 	char *drawname= pt->label;
 	char *idname= pt->idname;
@@ -292,7 +292,7 @@ void uiEndPanel(uiBlock *block, int width, int height)
 
 static void ui_offset_panel_block(uiBlock *block)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiBut *but;
 	int ofsy;
 
@@ -442,8 +442,12 @@ static void ui_draw_aligned_panel_header(uiStyle *style, uiBlock *block, rcti *r
 	Panel *panel= block->panel;
 	rcti hrect;
 	int  pnl_icons;
-	char *activename= panel->drawname[0]?panel->drawname:panel->panelname;
-	
+	const char *activename= panel->drawname[0]?panel->drawname:panel->panelname;
+
+#ifdef INTERNATIONAL
+	activename= UI_translate_do_iface(activename);
+#endif
+
 	/* + 0.001f to avoid flirting with float inaccuracy */
 	if(panel->control & UI_PNL_CLOSE) pnl_icons=(panel->labelofs+2*PNL_ICON+5)/block->aspect + 0.001f;
 	else pnl_icons= (panel->labelofs+PNL_ICON+5)/block->aspect + 0.001f;
@@ -667,7 +671,7 @@ static int compare_panel(const void *a1, const void *a2)
 /* returns 1 when it did something */
 static int uiAlignPanelStep(ScrArea *sa, ARegion *ar, float fac, int drag)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	Panel *pa;
 	PanelSort *ps, *panelsort, *psnext;
 	int a, tot=0, done;
diff --git a/source/blender/editors/interface/interface_regions.c b/source/blender/editors/interface/interface_regions.c
index f31c16cd020..4221f7c30ff 100644
--- a/source/blender/editors/interface/interface_regions.c
+++ b/source/blender/editors/interface/interface_regions.c
@@ -62,6 +62,7 @@
 #include "UI_view2d.h"
 
 #include "BLF_api.h"
+#include "BLF_translation.h"
 
 #include "ED_screen.h"
 
@@ -318,7 +319,7 @@ static void ui_tooltip_region_draw_cb(const bContext *UNUSED(C), ARegion *ar)
 	rcti bbox= data->bbox;
 	int a;
 	
-	ui_draw_menu_back(U.uistyles.first, NULL, &data->bbox);
+	ui_draw_menu_back(UI_GetStyle(), NULL, &data->bbox);
 	
 	/* draw text */
 	uiStyleFontSet(&data->fstyle);
@@ -343,9 +344,10 @@ static void ui_tooltip_region_free_cb(ARegion *ar)
 	ar->regiondata= NULL;
 }
 
+#define TIP_(msgid) UI_translate_do_tooltip(msgid)
 ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 {
-	uiStyle *style= U.uistyles.first;	// XXX pass on as arg
+	uiStyle *style= UI_GetStyle();
 	static ARegionType type;
 	ARegion *ar;
 	uiTooltipData *data;
@@ -374,7 +376,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 			EnumPropertyItem *item;
 			int i, totitem, free;
 
-			RNA_property_enum_items(C, &but->rnapoin, but->rnaprop, &item, &totitem, &free);
+			RNA_property_enum_items_gettexted(C, &but->rnapoin, but->rnaprop, &item, &totitem, &free);
 
 			for(i=0; i<totitem; i++) {
 				if(item[i].identifier[0] && item[i].value == (int)but->hardmax) {
@@ -403,7 +405,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 		prop= (but->opptr)? but->opptr->data: NULL;
 
 		if(WM_key_event_operator_string(C, but->optype->idname, but->opcontext, prop, buf, sizeof(buf))) {
-			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Shortcut: %s", buf);
+			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Shortcut: %s")), buf);
 			data->color[data->totline]= 0x888888;
 			data->totline++;
 		}
@@ -413,7 +415,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 		/* full string */
 		ui_get_but_string(but, buf, sizeof(buf));
 		if(buf[0]) {
-			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Value: %s", buf);
+			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Value: %s")), buf);
 			data->color[data->totline]= 0x888888;
 			data->totline++;
 		}
@@ -425,7 +427,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 		if (unit_type == PROP_UNIT_ROTATION) {
 			if (RNA_property_type(but->rnaprop) == PROP_FLOAT) {
 				float value= RNA_property_array_check(but->rnaprop) ? RNA_property_float_get_index(&but->rnapoin, but->rnaprop, but->rnaindex) : RNA_property_float_get(&but->rnapoin, but->rnaprop);
-				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Radians: %f", value);
+				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Radians: %f")), value);
 				data->color[data->totline]= 0x888888;
 				data->totline++;
 			}
@@ -434,7 +436,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 		if(but->flag & UI_BUT_DRIVEN) {
 			if(ui_but_anim_expression_get(but, buf, sizeof(buf))) {
 				/* expression */
-				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Expression: %s", buf);
+				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Expression: %s")), buf);
 				data->color[data->totline]= 0x888888;
 				data->totline++;
 			}
@@ -442,7 +444,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 
 		/* rna info */
 		if ((U.flag & USER_TOOLTIPS_PYTHON) == 0) {
-			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Python: %s.%s", RNA_struct_identifier(but->rnapoin.type), RNA_property_identifier(but->rnaprop));
+			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Python: %s.%s")), RNA_struct_identifier(but->rnapoin.type), RNA_property_identifier(but->rnaprop));
 			data->color[data->totline]= 0x888888;
 			data->totline++;
 		}
@@ -450,7 +452,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 		if(but->rnapoin.id.data) {
 			ID *id= but->rnapoin.id.data;
 			if(id->lib && id->lib->name) {
-				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Library: %s", id->lib->name);
+				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Library: %s")), id->lib->name);
 				data->color[data->totline]= 0x888888;
 				data->totline++;
 			}
@@ -465,7 +467,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 
 		/* operator info */
 		if ((U.flag & USER_TOOLTIPS_PYTHON) == 0) {
-			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Python: %s", str);
+			BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Python: %s")), str);
 			data->color[data->totline]= 0x888888;
 			data->totline++;
 		}
@@ -479,7 +481,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 			WM_operator_poll_context(C, but->optype, but->opcontext);
 			poll_msg= CTX_wm_operator_poll_msg_get(C);
 			if(poll_msg) {
-				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Disabled: %s", poll_msg);
+				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Disabled: %s")), poll_msg);
 				data->color[data->totline]= 0x6666ff; /* alert */
 				data->totline++;			
 			}
@@ -489,7 +491,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 		if ((U.flag & USER_TOOLTIPS_PYTHON) == 0) {
 			if(but->menu_create_func && WM_menutype_contains((MenuType *)but->poin)) {
 				MenuType *mt= (MenuType *)but->poin;
-				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Python: %s", mt->idname);
+				BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Python: %s")), mt->idname);
 				data->color[data->totline]= 0x888888;
 				data->totline++;
 			}
@@ -608,6 +610,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
 
 	return ar;
 }
+#undef TIP_
 
 void ui_tooltip_free(bContext *C, ARegion *ar)
 {
@@ -985,7 +988,7 @@ static void ui_searchbox_region_free_cb(ARegion *ar)
 
 ARegion *ui_searchbox_create(bContext *C, ARegion *butregion, uiBut *but)
 {
-	uiStyle *style= U.uistyles.first;	// XXX pass on as arg
+	uiStyle *style= UI_GetStyle();
 	static ARegionType type;
 	ARegion *ar;
 	uiSearchboxData *data;
@@ -2299,7 +2302,7 @@ static uiBlock *ui_block_func_POPUP(bContext *C, uiPopupBlockHandle *handle, voi
 uiPopupBlockHandle *ui_popup_menu_create(bContext *C, ARegion *butregion, uiBut *but, uiMenuCreateFunc menu_func, void *arg, char *str)
 {
 	wmWindow *window= CTX_wm_window(C);
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiPopupBlockHandle *handle;
 	uiPopupMenu *pup;
 	
@@ -2348,7 +2351,7 @@ uiPopupBlockHandle *ui_popup_menu_create(bContext *C, ARegion *butregion, uiBut
 /* only return handler, and set optional title */
 uiPopupMenu *uiPupMenuBegin(bContext *C, const char *title, int icon)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiPopupMenu *pup= MEM_callocN(sizeof(uiPopupMenu), "popup menu");
 	uiBut *but;
 	
diff --git a/source/blender/editors/interface/interface_style.c b/source/blender/editors/interface/interface_style.c
index 8d4b4209120..5ea20b33b3a 100644
--- a/source/blender/editors/interface/interface_style.c
+++ b/source/blender/editors/interface/interface_style.c
@@ -47,6 +47,7 @@
 
 
 #include "BLF_api.h"
+#include "BLF_translation.h"
 
 #include "UI_interface.h"
 
@@ -76,7 +77,7 @@
 
 /* ********************************************** */
 
-static uiStyle *ui_style_new(ListBase *styles, const char *name)
+static uiStyle *ui_style_new(ListBase *styles, const char *name, short uifont_id)
 {
 	uiStyle *style= MEM_callocN(sizeof(uiStyle), "new style");
 	
@@ -85,7 +86,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name)
 	
 	style->panelzoom= 1.0; /* unused */
 
-	style->paneltitle.uifont_id= UIFONT_DEFAULT;
+	style->paneltitle.uifont_id= uifont_id;
 	style->paneltitle.points= 12;
 	style->paneltitle.kerning= 1;
 	style->paneltitle.shadow= 1;
@@ -94,7 +95,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name)
 	style->paneltitle.shadowalpha= 0.15f;
 	style->paneltitle.shadowcolor= 1.0f;
 	
-	style->grouplabel.uifont_id= UIFONT_DEFAULT;
+	style->grouplabel.uifont_id= uifont_id;
 	style->grouplabel.points= 12;
 	style->grouplabel.kerning= 1;
 	style->grouplabel.shadow= 3;
@@ -102,7 +103,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name)
 	style->grouplabel.shady= -1;
 	style->grouplabel.shadowalpha= 0.25f;
 	
-	style->widgetlabel.uifont_id= UIFONT_DEFAULT;
+	style->widgetlabel.uifont_id= uifont_id;
 	style->widgetlabel.points= 11;
 	style->widgetlabel.kerning= 1;
 	style->widgetlabel.shadow= 3;
@@ -111,7 +112,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name)
 	style->widgetlabel.shadowalpha= 0.15f;
 	style->widgetlabel.shadowcolor= 1.0f;
 	
-	style->widget.uifont_id= UIFONT_DEFAULT;
+	style->widget.uifont_id= uifont_id;
 	style->widget.points= 11;
 	style->widget.kerning= 1;
 	style->widget.shadowalpha= 0.25f;
@@ -251,11 +252,19 @@ void uiStyleFontDrawRotated(uiFontStyle *fs, rcti *rect, const char *str)
 }
 
 /* ************** helpers ************************ */
+/* XXX: read a style configure */
+uiStyle* UI_GetStyle(void)
+{
+	uiStyle *style = NULL;
+	/* offset is two struct uiStyle pointers */
+	/* style = BLI_findstring( &U.uistyles, "Unifont Style", sizeof(style)*2 ) */;
+	return (style != NULL) ? style : U.uistyles.first;
+}
 
 /* temporarily, does widget font */
 int UI_GetStringWidth(const char *str)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiFontStyle *fstyle= &style->widget;
 	int width;
 	
@@ -274,7 +283,7 @@ int UI_GetStringWidth(const char *str)
 /* temporarily, does widget font */
 void UI_DrawString(float x, float y, const char *str)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	
 	if (style->widget.kerning == 1)
 		BLF_enable(style->widget.uifont_id, BLF_KERNING_DEFAULT);
@@ -313,7 +322,17 @@ void uiStyleInit(void)
 	for(font= U.uifonts.first; font; font= font->next) {
 		
 		if(font->uifont_id==UIFONT_DEFAULT) {
+#ifdef INTERNATIONAL
+			int unifont_size;
+			unsigned char *unifont_ttf= BLF_get_unifont(&unifont_size);
+
+			if(unifont_ttf)
+				font->blf_id= BLF_load_mem_unique("default", unifont_ttf, unifont_size);
+			else
+				font->blf_id= BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size);
+#else
 			font->blf_id= BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size);
+#endif
 		}		
 		else {
 			font->blf_id= BLF_load(font->filename);
@@ -337,7 +356,7 @@ void uiStyleInit(void)
 	}
 	
 	if(style==NULL) {
-		ui_style_new(&U.uistyles, "Default Style");
+		ui_style_new(&U.uistyles, "Default Style", UIFONT_DEFAULT );
 	}
 	
 	// XXX, this should be moved into a style, but for now best only load the monospaced font once.
diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c
index 493ccebc19e..af515bf8061 100644
--- a/source/blender/editors/interface/interface_templates.c
+++ b/source/blender/editors/interface/interface_templates.c
@@ -68,6 +68,7 @@
 #include "interface_intern.h"
 
 #include "BLF_api.h"
+#include "BLF_translation.h"
 
 void UI_template_fix_linking(void)
 {
@@ -306,31 +307,31 @@ static const char *template_id_browse_tip(StructRNA *type)
 {
 	if(type) {
 		switch(RNA_type_to_ID_code(type)) {
-			case ID_SCE: return "Browse Scene to be linked";
-			case ID_OB: return "Browse Object to be linked";
-			case ID_ME: return "Browse Mesh Data to be linked";
-			case ID_CU: return "Browse Curve Data to be linked";
-			case ID_MB: return "Browse MetaBall Data to be linked";
-			case ID_MA: return "Browse Material to be linked";
-			case ID_TE: return "Browse Texture to be linked";
-			case ID_IM: return "Browse Image to be linked";
-			case ID_LT: return "Browse Lattice Data to be linked";
-			case ID_LA: return "Browse Lamp Data to be linked";
-			case ID_CA: return "Browse Camera Data to be linked";
-			case ID_WO: return "Browse World Settings to be linked";
-			case ID_SCR: return "Choose Screen lay-out";
-			case ID_TXT: return "Browse Text to be linked";
-			case ID_SPK: return "Browse Speaker Data to be linked";
-			case ID_SO: return "Browse Sound to be linked";
-			case ID_AR: return "Browse Armature data to be linked";
-			case ID_AC: return "Browse Action to be linked";
-			case ID_NT: return "Browse Node Tree to be linked";
-			case ID_BR: return "Browse Brush to be linked";
-			case ID_PA: return "Browse Particle System to be linked";
-			case ID_GD: return "Browse Grease Pencil Data to be linked";
+			case ID_SCE: return N_("Browse Scene to be linked");
+			case ID_OB: return N_("Browse Object to be linked");
+			case ID_ME: return N_("Browse Mesh Data to be linked");
+			case ID_CU: return N_("Browse Curve Data to be linked");
+			case ID_MB: return N_("Browse MetaBall Data to be linked");
+			case ID_MA: return N_("Browse Material to be linked");
+			case ID_TE: return N_("Browse Texture to be linked");
+			case ID_IM: return N_("Browse Image to be linked");
+			case ID_LT: return N_("Browse Lattice Data to be linked");
+			case ID_LA: return N_("Browse Lamp Data to be linked");
+			case ID_CA: return N_("Browse Camera Data to be linked");
+			case ID_WO: return N_("Browse World Settings to be linked");
+			case ID_SCR: return N_("Choose Screen lay-out");
+			case ID_TXT: return N_("Browse Text to be linked");
+			case ID_SPK: return N_("Browse Speaker Data to be linked");
+			case ID_SO: return N_("Browse Sound to be linked");
+			case ID_AR: return N_("Browse Armature data to be linked");
+			case ID_AC: return N_("Browse Action to be linked");
+			case ID_NT: return N_("Browse Node Tree to be linked");
+			case ID_BR: return N_("Browse Brush to be linked");
+			case ID_PA: return N_("Browse Particle System to be linked");
+			case ID_GD: return N_("Browse Grease Pencil Data to be linked");
 		}
 	}
-	return "Browse ID data to be linked";
+	return N_("Browse ID data to be linked");
 }
 
 static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, StructRNA *type, int flag, const char *newop, const char *openop, const char *unlinkop)
@@ -355,7 +356,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 
 	if(flag & UI_ID_PREVIEWS) {
 
-		but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*6, UI_UNIT_Y*6, template_id_browse_tip(type));
+		but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*6, UI_UNIT_Y*6,
+				UI_translate_do_tooltip(template_id_browse_tip(type)));
 		if(type) {
 			but->icon= RNA_struct_ui_icon(type);
 			if (id) but->icon = ui_id_icon_get(C, id, 1);
@@ -367,7 +369,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 		uiLayoutRow(layout, 1);
 	}
 	else if(flag & UI_ID_BROWSE) {
-		but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*1.6, UI_UNIT_Y, template_id_browse_tip(type));
+		but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*1.6, UI_UNIT_Y,
+				UI_translate_do_tooltip(template_id_browse_tip(type)));
 		if(type) {
 			but->icon= RNA_struct_ui_icon(type);
 			/* default dragging of icon for id browse buttons */
@@ -393,12 +396,12 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 		if(id->lib) {
 			if(id->flag & LIB_INDIRECT) {
 				but= uiDefIconBut(block, BUT, 0, ICON_LIBRARY_DATA_INDIRECT, 0,0,UI_UNIT_X,UI_UNIT_Y, NULL, 0, 0, 0, 0,
-					"Indirect library datablock, cannot change");
+					UI_translate_do_tooltip(N_("Indirect library datablock, cannot change")));
 				uiButSetFlag(but, UI_BUT_DISABLED);
 			}
 			else {
 				but= uiDefIconBut(block, BUT, 0, ICON_LIBRARY_DATA_DIRECT, 0,0,UI_UNIT_X,UI_UNIT_Y, NULL, 0, 0, 0, 0,
-					"Direct linked library datablock, click to make local");
+					UI_translate_do_tooltip(N_("Direct linked library datablock, click to make local")));
 				if(!id_make_local(id, 1 /* test */) || (idfrom && idfrom->lib))
 					uiButSetFlag(but, UI_BUT_DISABLED);
 			}
@@ -411,7 +414,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 
 			sprintf(str, "%d", id->us);
 
-			but= uiDefBut(block, BUT, 0, str, 0,0,UI_UNIT_X + ((id->us < 10) ? 0:10), UI_UNIT_Y, NULL, 0, 0, 0, 0, "Displays number of users of this data, click to make a single-user copy");
+			but= uiDefBut(block, BUT, 0, str, 0,0,UI_UNIT_X + ((id->us < 10) ? 0:10), UI_UNIT_Y, NULL, 0, 0, 0, 0,
+						UI_translate_do_tooltip(_("Displays number of users of this data. Click to make a single-user copy")));
 
 			uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_ALONE));
 			if(!id_copy(id, NULL, 1 /* test only */) || (idfrom && idfrom->lib) || !editable)
@@ -429,11 +433,11 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 		int w= id?UI_UNIT_X: (flag & UI_ID_OPEN)? UI_UNIT_X*3: UI_UNIT_X*6;
 		
 		if(newop) {
-			but= uiDefIconTextButO(block, BUT, newop, WM_OP_INVOKE_DEFAULT, ICON_ZOOMIN, (id)? "": "New", 0, 0, w, UI_UNIT_Y, NULL);
+			but= uiDefIconTextButO(block, BUT, newop, WM_OP_INVOKE_DEFAULT, ICON_ZOOMIN, (id)? "": UI_translate_do_iface(N_("New")), 0, 0, w, UI_UNIT_Y, NULL);
 			uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_ADD_NEW));
 		}
 		else {
-			but= uiDefIconTextBut(block, BUT, 0, ICON_ZOOMIN, (id)? "": "New", 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL);
+			but= uiDefIconTextBut(block, BUT, 0, ICON_ZOOMIN, (id)? "": _("New"), 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL);
 			uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_ADD_NEW));
 		}
 
@@ -445,11 +449,11 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 		int w= id?UI_UNIT_X: (flag & UI_ID_ADD_NEW)? UI_UNIT_X*3: UI_UNIT_X*6;
 		
 		if(openop) {
-			but= uiDefIconTextButO(block, BUT, openop, WM_OP_INVOKE_DEFAULT, ICON_FILESEL, (id)? "": "Open", 0, 0, w, UI_UNIT_Y, NULL);
+			but= uiDefIconTextButO(block, BUT, openop, WM_OP_INVOKE_DEFAULT, ICON_FILESEL, (id)? "": UI_translate_do_iface(N_("Open")), 0, 0, w, UI_UNIT_Y, NULL);
 			uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_OPEN));
 		}
 		else {
-			but= uiDefIconTextBut(block, BUT, 0, ICON_FILESEL, (id)? "": "Open", 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL);
+			but= uiDefIconTextBut(block, BUT, 0, ICON_FILESEL, (id)? "": UI_translate_do_iface(N_("Open")), 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL);
 			uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_OPEN));
 		}
 
@@ -465,7 +469,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str
 			uiButSetNFunc(but, NULL, MEM_dupallocN(template), NULL);
 		}
 		else {
-			but= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, "Unlink datablock. Shift + Click to set users to zero, data will then not be saved");
+			but= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0,
+					UI_translate_do_tooltip(N_("Unlink datablock. Shift + Click to set users to zero, data will then not be saved")));
 			uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_DELETE));
 
 			if(RNA_property_flag(template->prop) & PROP_NEVER_NULL)
@@ -722,7 +727,8 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif
 		sprintf(str, "%s parent deform", md->name);
 		uiDefBut(block, LABEL, 0, str, 0, 0, 185, UI_UNIT_Y, NULL, 0.0, 0.0, 0.0, 0.0, "Modifier name"); 
 		
-		but = uiDefBut(block, BUT, 0, "Make Real", 0, 0, 80, 16, NULL, 0.0, 0.0, 0.0, 0.0, "Convert virtual modifier to a real modifier");
+		but = uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Make Real")), 0, 0, 80, 16, NULL, 0.0, 0.0, 0.0, 0.0,
+					UI_translate_do_tooltip(N_("Convert virtual modifier to a real modifier")));
 		uiButSetFunc(but, modifiers_convertToReal, ob, md);
 	}
 	else {
@@ -756,7 +762,8 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif
 		if ((ob->type==OB_MESH) && modifier_couldBeCage(scene, md) && (index <= lastCageIndex)) 
 		{
 			/* -- convert to rna ? */
-			but = uiDefIconButBitI(block, TOG, eModifierMode_OnCage, 0, ICON_MESH_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0, "Apply modifier to editing cage during Editmode");
+			but = uiDefIconButBitI(block, TOG, eModifierMode_OnCage, 0, ICON_MESH_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0,
+					UI_translate_do_tooltip(N_("Apply modifier to editing cage during Editmode")));
 			if (index < cageIndex)
 				uiButSetFlag(but, UI_BUT_DISABLED);
 			uiButSetFunc(but, modifiers_setOnCage, ob, md);
@@ -768,7 +775,8 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif
 			if (ELEM3(md->type, eModifierType_Hook, eModifierType_Softbody, eModifierType_MeshDeform)) {
 				/* add disabled pre-tesselated button, so users could have
 				   message for this modifiers */
-				but = uiDefIconButBitI(block, TOG, eModifierMode_ApplyOnSpline, 0, ICON_SURFACE_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0, "This modifier could be applied on splines' points only");
+				but = uiDefIconButBitI(block, TOG, eModifierMode_ApplyOnSpline, 0, ICON_SURFACE_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0,
+						UI_translate_do_tooltip(N_("This modifier could be applied on splines' points only")));
 				uiButSetFlag(but, UI_BUT_DISABLED);
 			} else if (mti->type != eModifierTypeType_Constructive) {
 				/* constructive modifiers tesselates curve before applying */
@@ -818,17 +826,17 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif
 			}
 			else {
 				uiLayoutSetOperatorContext(row, WM_OP_INVOKE_DEFAULT);
-				uiItemEnumO(row, "OBJECT_OT_modifier_apply", "Apply", 0, "apply_as", MODIFIER_APPLY_DATA);
+				uiItemEnumO(row, "OBJECT_OT_modifier_apply", UI_translate_do_iface(N_("Apply")), 0, "apply_as", MODIFIER_APPLY_DATA);
 				
 				if (modifier_sameTopology(md))
-					uiItemEnumO(row, "OBJECT_OT_modifier_apply", "Apply as Shape", 0, "apply_as", MODIFIER_APPLY_SHAPE);
+					uiItemEnumO(row, "OBJECT_OT_modifier_apply", UI_translate_do_iface(N_("Apply as Shape")), 0, "apply_as", MODIFIER_APPLY_SHAPE);
 			}
 			
 			uiBlockClearButLock(block);
 			uiBlockSetButLock(block, ob && ob->id.lib, ERROR_LIBDATA_MESSAGE);
 			
 			if (!ELEM5(md->type, eModifierType_Fluidsim, eModifierType_Softbody, eModifierType_ParticleSystem, eModifierType_Cloth, eModifierType_Smoke))
-				uiItemO(row, "Copy", ICON_NONE, "OBJECT_OT_modifier_copy");
+				uiItemO(row, UI_translate_do_tooltip(N_("Copy")), ICON_NONE, "OBJECT_OT_modifier_copy");
 		}
 		
 		/* result is the layout block inside the box, that we return so that modifier settings can be drawn */
@@ -1005,8 +1013,8 @@ static uiLayout *draw_constraint(uiLayout *layout, Object *ob, bConstraint *con)
 		uiBlockSetEmboss(block, UI_EMBOSSN);
 		
 		/* draw a ghost icon (for proxy) and also a lock beside it, to show that constraint is "proxy locked" */
-		uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_GHOST, xco+244, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, "Proxy Protected");
-		uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_LOCKED, xco+262, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, "Proxy Protected");
+		uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_GHOST, xco+244, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Proxy Protected")));
+		uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_LOCKED, xco+262, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Proxy Protected")));
 		
 		uiBlockSetEmboss(block, UI_EMBOSS);
 	}
@@ -1192,14 +1200,14 @@ void uiTemplatePreview(uiLayout *layout, ID *id, int show_buttons, ID *parent, M
 			RNA_pointer_create(id, &RNA_Texture, tex, &texture_ptr);
 			
 			uiLayoutRow(layout, 1);
-			uiDefButS(block, ROW, B_MATPRV, "Texture",  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_TEXTURE, 0, 0, "");
+			uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Texture")),  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_TEXTURE, 0, 0, "");
 			if(GS(parent->name) == ID_MA)
-				uiDefButS(block, ROW, B_MATPRV, "Material",  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, "");
+				uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Material")),  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, "");
 			else if(GS(parent->name) == ID_LA)
-				uiDefButS(block, ROW, B_MATPRV, "Lamp",  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, "");
+				uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Lamp")),  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, "");
 			else if(GS(parent->name) == ID_WO)
-				uiDefButS(block, ROW, B_MATPRV, "World",  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, "");
-			uiDefButS(block, ROW, B_MATPRV, "Both",  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_BOTH, 0, 0, "");
+				uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("World")),  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, "");
+			uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Both")),  0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_BOTH, 0, 0, "");
 			
 			/* Alpha buton for texture preview */
 			if(*pr_texture!=TEX_PR_OTHER) {
@@ -1290,21 +1298,23 @@ static void colorband_buttons_large(uiLayout *layout, uiBlock *block, ColorBand
 
 	if(coba==NULL) return;
 
-	bt= uiDefBut(block, BUT, 0,	"Add",			0+xoffs,line1_y,40,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Add a new color stop to the colorband");
+	bt= uiDefBut(block, BUT, 0,	UI_translate_do_iface(N_("Add")), 0+xoffs,line1_y,40,UI_UNIT_Y, NULL, 0, 0, 0, 0,
+			UI_translate_do_tooltip(N_("Add a new color stop to the colorband")));
 	uiButSetNFunc(bt, colorband_add_cb, MEM_dupallocN(cb), coba);
 
-	bt= uiDefBut(block, BUT, 0,	"Delete",		45+xoffs,line1_y,45,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Delete the active position");
+	bt= uiDefBut(block, BUT, 0,	UI_translate_do_iface(N_("Delete")), 45+xoffs,line1_y,45,UI_UNIT_Y, NULL, 0, 0, 0, 0,
+			UI_translate_do_tooltip(N_("Delete the active position")));
 	uiButSetNFunc(bt, colorband_del_cb, MEM_dupallocN(cb), coba);
 
 
 	/* XXX, todo for later - convert to operator - campbell */
-	bt= uiDefBut(block, BUT, 0,	"F",		95+xoffs,line1_y,20,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Flip colorband");
+	bt= uiDefBut(block, BUT, 0,	"F",		95+xoffs,line1_y,20,UI_UNIT_Y, NULL, 0, 0, 0, 0, UI_translate_do_tooltip(N_("Flip colorband")));
 	uiButSetNFunc(bt, colorband_flip_cb, MEM_dupallocN(cb), coba);
 
-	uiDefButS(block, NUM, 0,		"",				120+xoffs,line1_y,80, UI_UNIT_Y, &coba->cur, 0.0, (float)(MAX2(0, coba->tot-1)), 0, 0, "Choose active color stop");
+	uiDefButS(block, NUM, 0,		"",				120+xoffs,line1_y,80, UI_UNIT_Y, &coba->cur, 0.0, (float)(MAX2(0, coba->tot-1)), 0, 0, UI_translate_do_tooltip(N_("Choose active color stop")));
 
-	bt= uiDefButS(block, MENU, 0,		"Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4",
-			210+xoffs, line1_y, 90, UI_UNIT_Y,		&coba->ipotype, 0.0, 0.0, 0, 0, "Set interpolation between color stops");
+	bt= uiDefButS(block, MENU, 0,		UI_translate_do_iface(N_("Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4")),
+			210+xoffs, line1_y, 90, UI_UNIT_Y,		&coba->ipotype, 0.0, 0.0, 0, 0, UI_translate_do_tooltip(N_("Set interpolation between color stops")));
 	uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL);
 	uiBlockEndAlign(block);
 
@@ -1333,11 +1343,13 @@ static void colorband_buttons_small(uiLayout *layout, uiBlock *block, ColorBand
 	float xs= butr->xmin;
 
 	uiBlockBeginAlign(block);
-	bt= uiDefBut(block, BUT, 0,	"Add",			xs,butr->ymin+UI_UNIT_Y,2.0f*unit,UI_UNIT_Y,	NULL, 0, 0, 0, 0, "Add a new color stop to the colorband");
+	bt= uiDefBut(block, BUT, 0,	UI_translate_do_iface(N_("Add")), xs,butr->ymin+UI_UNIT_Y,2.0f*unit,UI_UNIT_Y,	NULL, 0, 0, 0, 0,
+			UI_translate_do_tooltip(N_("Add a new color stop to the colorband")));
 	uiButSetNFunc(bt, colorband_add_cb, MEM_dupallocN(cb), coba);
-	bt= uiDefBut(block, BUT, 0,	"Delete",		xs+2.0f*unit,butr->ymin+UI_UNIT_Y,1.5f*unit,UI_UNIT_Y,	NULL, 0, 0, 0, 0, "Delete the active position");
+	bt= uiDefBut(block, BUT, 0,	UI_translate_do_iface(N_("Delete")), xs+2.0f*unit,butr->ymin+UI_UNIT_Y,1.5f*unit,UI_UNIT_Y,	NULL, 0, 0, 0, 0,
+	             UI_translate_do_tooltip(N_("Delete the active position")));
 	uiButSetNFunc(bt, colorband_del_cb, MEM_dupallocN(cb), coba);
-	bt= uiDefBut(block, BUT, 0,	"F",		xs+3.5f*unit,butr->ymin+UI_UNIT_Y,0.5f*unit,UI_UNIT_Y,	NULL, 0, 0, 0, 0, "Flip the color ramp");
+	bt= uiDefBut(block, BUT, 0,	"F",		xs+3.5f*unit,butr->ymin+UI_UNIT_Y,0.5f*unit,UI_UNIT_Y,	NULL, 0, 0, 0, 0, UI_translate_do_tooltip(N_("Flip the color ramp")));
 	uiButSetNFunc(bt, colorband_flip_cb, MEM_dupallocN(cb), coba);
 	uiBlockEndAlign(block);
 
@@ -1348,8 +1360,9 @@ static void colorband_buttons_small(uiLayout *layout, uiBlock *block, ColorBand
 		uiItemR(layout, &ptr, "color", 0, "", ICON_NONE);
 	}
 
-	bt= uiDefButS(block, MENU, 0,		"Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4",
-			xs+10.0f*unit, butr->ymin+UI_UNIT_Y, unit*4, UI_UNIT_Y,		&coba->ipotype, 0.0, 0.0, 0, 0, "Set interpolation between color stops");
+	bt= uiDefButS(block, MENU, 0, UI_translate_do_tooltip(N_("Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4")),
+			xs+10.0f*unit, butr->ymin+UI_UNIT_Y, unit*4, UI_UNIT_Y,		&coba->ipotype, 0.0, 0.0, 0, 0,
+			UI_translate_do_tooltip(N_("Set interpolation between color stops")));
 	uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL);
 
 	bt= uiDefBut(block, BUT_COLORBAND, 0, "",		xs,butr->ymin,butr->xmax-butr->xmin,UI_UNIT_Y, coba, 0, 0, 0, 0, "");
@@ -1600,10 +1613,10 @@ static uiBlock *curvemap_clipping_func(bContext *C, struct ARegion *ar, void *cu
 	uiButSetFunc(bt, curvemap_buttons_setclip, cumap, NULL);
 
 	uiBlockBeginAlign(block);
-	uiDefButF(block, NUM, 0, "Min X ",	 0,4*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmin, -100.0, cumap->clipr.xmax, 10, 0, "");
-	uiDefButF(block, NUM, 0, "Min Y ",	 0,3*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymin, -100.0, cumap->clipr.ymax, 10, 0, "");
-	uiDefButF(block, NUM, 0, "Max X ",	 0,2*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmax, cumap->clipr.xmin, 100.0, 10, 0, "");
-	uiDefButF(block, NUM, 0, "Max Y ",	 0,UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymax, cumap->clipr.ymin, 100.0, 10, 0, "");
+	uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Min X ")),	 0,4*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmin, -100.0, cumap->clipr.xmax, 10, 0, "");
+	uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Min Y ")),	 0,3*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymin, -100.0, cumap->clipr.ymax, 10, 0, "");
+	uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Max X ")),	 0,2*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmax, cumap->clipr.xmin, 100.0, 10, 0, "");
+	uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Max Y ")),	 0,UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymax, cumap->clipr.ymin, 100.0, 10, 0, "");
 
 	uiBlockSetDirection(block, UI_RIGHT);
 
@@ -1652,12 +1665,12 @@ static uiBlock *curvemap_tools_func(bContext *C, struct ARegion *ar, void *cumap
 	block= uiBeginBlock(C, ar, "curvemap_tools_func", UI_EMBOSS);
 	uiBlockSetButmFunc(block, curvemap_tools_dofunc, cumap_v);
 
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset View",				0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Vector Handle",			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Auto Handle",			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Extend Horizontal",		0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 4, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Extend Extrapolated",	0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 5, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset Curve",			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset View")),			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Vector Handle")),		0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Auto Handle")),			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Extend Horizontal")),	0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 4, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Extend Extrapolated")),	0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 5, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset Curve")),			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
 
 	uiBlockSetDirection(block, UI_RIGHT);
 	uiTextBoundsBlock(block, 50);
@@ -1674,10 +1687,10 @@ static uiBlock *curvemap_brush_tools_func(bContext *C, struct ARegion *ar, void
 	block= uiBeginBlock(C, ar, "curvemap_tools_func", UI_EMBOSS);
 	uiBlockSetButmFunc(block, curvemap_tools_dofunc, cumap_v);
 
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset View",				0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Vector Handle",			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Auto Handle",			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset Curve",			0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset View")),		0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Vector Handle")),	0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Auto Handle")),		0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset Curve")),		0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, "");
 
 	uiBlockSetDirection(block, UI_RIGHT);
 	uiTextBoundsBlock(block, 50);
@@ -1794,24 +1807,24 @@ static void curvemap_buttons_layout(uiLayout *layout, PointerRNA *ptr, char labe
 
 	uiBlockSetEmboss(block, UI_EMBOSSN);
 
-	bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMIN, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, "Zoom in");
+	bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMIN, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Zoom in")));
 	uiButSetFunc(bt, curvemap_buttons_zoom_in, cumap, NULL);
 
-	bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMOUT, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, "Zoom out");
+	bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMOUT, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Zoom out")));
 	uiButSetFunc(bt, curvemap_buttons_zoom_out, cumap, NULL);
 
 	if(brush)
-		bt= uiDefIconBlockBut(block, curvemap_brush_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, "Tools");
+		bt= uiDefIconBlockBut(block, curvemap_brush_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, UI_translate_do_tooltip(N_("Tools")));
 	else
-		bt= uiDefIconBlockBut(block, curvemap_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, "Tools");
+		bt= uiDefIconBlockBut(block, curvemap_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, UI_translate_do_tooltip(N_("Tools")));
 
 	uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL);
 
 	if(cumap->flag & CUMA_DO_CLIP) icon= ICON_CLIPUV_HLT; else icon= ICON_CLIPUV_DEHLT;
-	bt= uiDefIconBlockBut(block, curvemap_clipping_func, cumap, 0, icon, 0, 0, dx, dx, "Clipping Options");
+	bt= uiDefIconBlockBut(block, curvemap_clipping_func, cumap, 0, icon, 0, 0, dx, dx, UI_translate_do_tooltip(N_("Clipping Options")));
 	uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL);
 
-	bt= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, "Delete points");
+	bt= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Delete points")));
 	uiButSetNFunc(bt, curvemap_buttons_delete, MEM_dupallocN(cb), cumap);
 
 	uiBlockSetEmboss(block, UI_EMBOSS);
@@ -1830,7 +1843,8 @@ static void curvemap_buttons_layout(uiLayout *layout, PointerRNA *ptr, char labe
 		uiItemR(uiLayoutColumn(split, 0), ptr, "white_level", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
 
 		uiLayoutRow(layout, 0);
-		bt=uiDefBut(block, BUT, 0, "Reset",	0, 0, UI_UNIT_X*10, UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "Reset Black/White point and curves");
+		bt=uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Reset")),	0, 0, UI_UNIT_X*10, UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0,
+				UI_translate_do_tooltip(N_("Reset Black/White point and curves")));
 		uiButSetNFunc(bt, curvemap_buttons_reset, MEM_dupallocN(cb), cumap);
 	}
 
@@ -2449,16 +2463,18 @@ void uiTemplateRunningJobs(uiLayout *layout, bContext *C)
 		(void)ui_abs; // UNUSED
 		
 		uiDefIconBut(block, BUT, handle_event, ICON_PANEL_CLOSE, 
-				0, UI_UNIT_Y*0.1, UI_UNIT_X*0.8, UI_UNIT_Y*0.8, NULL, 0.0f, 0.0f, 0, 0, "Stop this job");
+				0, UI_UNIT_Y*0.1, UI_UNIT_X*0.8, UI_UNIT_Y*0.8, NULL, 0.0f, 0.0f, 0, 0, UI_translate_do_tooltip(N_("Stop this job")));
 		uiDefBut(block, PROGRESSBAR, 0, WM_jobs_name(wm, owner), 
-				UI_UNIT_X, 0, 100, UI_UNIT_Y, NULL, 0.0f, 0.0f, WM_jobs_progress(wm, owner), 0, "Progress");
+				UI_UNIT_X, 0, 100, UI_UNIT_Y, NULL, 0.0f, 0.0f, WM_jobs_progress(wm, owner), 0, UI_translate_do_tooltip(N_("Progress")));
 		
 		uiLayoutRow(layout, 0);
 	}
 	if(WM_jobs_test(wm, screen))
-		uiDefIconTextBut(block, BUT, B_STOPCAST, ICON_CANCEL, "Capture", 0,0,85,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "Stop screencast");
+		uiDefIconTextBut(block, BUT, B_STOPCAST, ICON_CANCEL, UI_translate_do_iface(N_("Capture")), 0,0,85,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0,
+				UI_translate_do_tooltip(N_("Stop screencast")));
 	if(screen->animtimer)
-		uiDefIconTextBut(block, BUT, B_STOPANIM, ICON_CANCEL, "Anim Player", 0,0,100,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "Stop animation playback");
+		uiDefIconTextBut(block, BUT, B_STOPANIM, ICON_CANCEL, UI_translate_do_tooltip(N_("Anim Player")), 0,0,100,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0,
+				UI_translate_do_tooltip(N_("Stop animation playback")));
 }
 
 /************************* Reports for Last Operator Template **************************/
@@ -2520,7 +2536,7 @@ void uiTemplateReportsBanner(uiLayout *layout, bContext *C)
 	uiBlockSetEmboss(block, UI_EMBOSSN);
 
 	if (reports->list.first != reports->list.last)
-		uiDefIconButO(block, BUT, "UI_OT_reports_to_textblock", WM_OP_INVOKE_REGION_WIN, icon, 2, 0, UI_UNIT_X, UI_UNIT_Y, "Click to see rest of reports in textblock: 'Recent Reports'");
+		uiDefIconButO(block, BUT, "UI_OT_reports_to_textblock", WM_OP_INVOKE_REGION_WIN, icon, 2, 0, UI_UNIT_X, UI_UNIT_Y, UI_translate_do_tooltip(N_("Click to see rest of reports in textblock: 'Recent Reports'")));
 	else
 		uiDefIconBut(block, LABEL, 0, icon, 2, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "");
 
diff --git a/source/blender/editors/interface/interface_utils.c b/source/blender/editors/interface/interface_utils.c
index a3f56192cb5..a49060eaca2 100644
--- a/source/blender/editors/interface/interface_utils.c
+++ b/source/blender/editors/interface/interface_utils.c
@@ -37,6 +37,8 @@
 
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 
 
@@ -114,7 +116,7 @@ uiBut *uiDefAutoButR(uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, int ind
 		}
 		case PROP_COLLECTION: {
 			char text[256];
-			sprintf(text, "%d items", RNA_property_collection_length(ptr, prop));
+			sprintf(text, UI_translate_do_iface(N_("%d items")), RNA_property_collection_length(ptr, prop));
 			but= uiDefBut(block, LABEL, 0, text, x1, y1, x2, y2, NULL, 0, 0, 0, 0, NULL);
 			uiButSetFlag(but, UI_BUT_DISABLED);
 			break;
diff --git a/source/blender/editors/interface/view2d.c b/source/blender/editors/interface/view2d.c
index 9242ddc2f60..18db1c8c894 100644
--- a/source/blender/editors/interface/view2d.c
+++ b/source/blender/editors/interface/view2d.c
@@ -168,7 +168,7 @@ static void view2d_masks(View2D *v2d)
 void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy)
 {
 	short tot_changed= 0, init= 0;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 
 	/* initialise data if there is a need for such */
 	if ((v2d->flag & V2D_IS_INITIALISED) == 0) {
diff --git a/source/blender/editors/interface/view2d_ops.c b/source/blender/editors/interface/view2d_ops.c
index 460c2f038a4..0aaf6fe3bc6 100644
--- a/source/blender/editors/interface/view2d_ops.c
+++ b/source/blender/editors/interface/view2d_ops.c
@@ -51,6 +51,7 @@
 #include "ED_screen.h"
 
 #include "UI_view2d.h"
+#include "UI_interface.h"
 
 #include "PIL_time.h" /* USER_ZOOM_CONT */
 
@@ -1587,7 +1588,7 @@ static void VIEW2D_OT_scroller_activate(wmOperatorType *ot)
 
 static int reset_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	ARegion *ar= CTX_wm_region(C);
 	View2D *v2d= &ar->v2d;
 	int winx, winy;
diff --git a/source/blender/editors/screen/area.c b/source/blender/editors/screen/area.c
index d41d3245623..8951df9221e 100644
--- a/source/blender/editors/screen/area.c
+++ b/source/blender/editors/screen/area.c
@@ -43,6 +43,8 @@
 #include "BLI_rand.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_global.h"
 #include "BKE_screen.h"
@@ -1347,7 +1349,7 @@ void ED_area_prevspace(bContext *C, ScrArea *sa)
 
 static const char *editortype_pup(void)
 {
-	return(
+	const char *types= N_(
 		   "Editor type:%t"
 		   "|3D View %x1"
 
@@ -1382,6 +1384,8 @@ static const char *editortype_pup(void)
 		   
 		   "|Python Console %x18"
 		   );
+
+	return UI_translate_do_iface(types);
 }
 
 static void spacefunc(struct bContext *C, void *UNUSED(arg1), void *UNUSED(arg2))
@@ -1403,8 +1407,7 @@ int ED_area_header_switchbutton(const bContext *C, uiBlock *block, int yco)
 	but= uiDefIconTextButC(block, ICONTEXTROW, 0, ICON_VIEW3D, 
 						   editortype_pup(), xco, yco, UI_UNIT_X+10, UI_UNIT_Y, 
 						   &(sa->butspacetype), 1.0, SPACEICONMAX, 0, 0, 
-						   "Displays current editor type. "
-						   "Click for menu of available types");
+						   UI_translate_do_tooltip(N_("Displays current editor type. Click for menu of available types")));
 	uiButSetFunc(but, spacefunc, NULL, NULL);
 	uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */
 	
@@ -1449,7 +1452,7 @@ int ED_area_header_standardbuttons(const bContext *C, uiBlock *block, int yco)
 void ED_region_panels(const bContext *C, ARegion *ar, int vertical, const char *context, int contextnr)
 {
 	ScrArea *sa= CTX_wm_area(C);
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiBlock *block;
 	PanelType *pt;
 	Panel *panel;
@@ -1637,7 +1640,7 @@ void ED_region_panels_init(wmWindowManager *wm, ARegion *ar)
 
 void ED_region_header(const bContext *C, ARegion *ar)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiBlock *block;
 	uiLayout *layout;
 	HeaderType *ht;
diff --git a/source/blender/editors/space_buttons/CMakeLists.txt b/source/blender/editors/space_buttons/CMakeLists.txt
index 631e2adea34..a9aaf6a6d58 100644
--- a/source/blender/editors/space_buttons/CMakeLists.txt
+++ b/source/blender/editors/space_buttons/CMakeLists.txt
@@ -21,6 +21,7 @@
 
 set(INC
 	../include
+	../../blenfont
 	../../blenkernel
 	../../blenlib
 	../../blenloader
diff --git a/source/blender/editors/space_buttons/SConscript b/source/blender/editors/space_buttons/SConscript
index a4270f1f59a..740353bc1f0 100644
--- a/source/blender/editors/space_buttons/SConscript
+++ b/source/blender/editors/space_buttons/SConscript
@@ -3,7 +3,7 @@ Import ('env')
 
 sources = env.Glob('*.c')
 
-incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
+incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
 incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
 incs += ' ../../makesrna ../../render/extern/include ../../blenloader'
 
diff --git a/source/blender/editors/space_buttons/buttons_header.c b/source/blender/editors/space_buttons/buttons_header.c
index e631718b0cb..b18b5373240 100644
--- a/source/blender/editors/space_buttons/buttons_header.c
+++ b/source/blender/editors/space_buttons/buttons_header.c
@@ -37,6 +37,7 @@
 #include "BLI_blenlib.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
 
 #include "BKE_context.h"
 
@@ -124,24 +125,23 @@ void buttons_header_buttons(const bContext *C, ARegion *ar)
 
 #define BUTTON_HEADER_CTX(_ctx, _icon, _tip) \
 	if(sbuts->pathflag & (1<<_ctx)) { \
-		but= uiDefIconButS(block, ROW, B_CONTEXT_SWITCH, _icon, xco+=BUT_UNIT_X, yco, BUT_UNIT_X, UI_UNIT_Y, &(sbuts->mainb), 0.0, (float)_ctx, 0, 0, _tip); \
+		but= uiDefIconButS(block, ROW, B_CONTEXT_SWITCH, _icon, xco+=BUT_UNIT_X, yco, BUT_UNIT_X, UI_UNIT_Y, &(sbuts->mainb), 0.0, (float)_ctx, 0, 0, UI_translate_do_tooltip(_tip)); \
 		uiButClearFlag(but, UI_BUT_UNDO); \
 	} \
 
-
-	BUTTON_HEADER_CTX(BCONTEXT_RENDER, ICON_SCENE, "Render")
-	BUTTON_HEADER_CTX(BCONTEXT_SCENE, ICON_SCENE_DATA, "Scene");
-	BUTTON_HEADER_CTX(BCONTEXT_WORLD, ICON_WORLD, "World");
-	BUTTON_HEADER_CTX(BCONTEXT_OBJECT, ICON_OBJECT_DATA, "Object");
-	BUTTON_HEADER_CTX(BCONTEXT_CONSTRAINT, ICON_CONSTRAINT, "Object Constraints");
-	BUTTON_HEADER_CTX(BCONTEXT_MODIFIER, ICON_MODIFIER, "Object Modifiers");
-	BUTTON_HEADER_CTX(BCONTEXT_DATA, sbuts->dataicon, "Object Data");
-	BUTTON_HEADER_CTX(BCONTEXT_BONE, ICON_BONE_DATA, "Bone");
-	BUTTON_HEADER_CTX(BCONTEXT_BONE_CONSTRAINT, ICON_CONSTRAINT_BONE, "Bone Constraints");
-	BUTTON_HEADER_CTX(BCONTEXT_MATERIAL, ICON_MATERIAL, "Material");
-	BUTTON_HEADER_CTX(BCONTEXT_TEXTURE, ICON_TEXTURE, "Textures");
-	BUTTON_HEADER_CTX(BCONTEXT_PARTICLE, ICON_PARTICLES, "Particles");
-	BUTTON_HEADER_CTX(BCONTEXT_PHYSICS, ICON_PHYSICS, "Physics");
+	BUTTON_HEADER_CTX(BCONTEXT_RENDER, ICON_SCENE, N_("Render"))
+	BUTTON_HEADER_CTX(BCONTEXT_SCENE, ICON_SCENE_DATA, N_("Scene"));
+	BUTTON_HEADER_CTX(BCONTEXT_WORLD, ICON_WORLD, N_("World"));
+	BUTTON_HEADER_CTX(BCONTEXT_OBJECT, ICON_OBJECT_DATA, N_("Object"));
+	BUTTON_HEADER_CTX(BCONTEXT_CONSTRAINT, ICON_CONSTRAINT, N_("Object Constraints"));
+	BUTTON_HEADER_CTX(BCONTEXT_MODIFIER, ICON_MODIFIER, N_("Object Modifiers"));
+	BUTTON_HEADER_CTX(BCONTEXT_DATA, sbuts->dataicon, N_("Object Data"));
+	BUTTON_HEADER_CTX(BCONTEXT_BONE, ICON_BONE_DATA, N_("Bone"));
+	BUTTON_HEADER_CTX(BCONTEXT_BONE_CONSTRAINT, ICON_CONSTRAINT_BONE, N_("Bone Constraints"));
+	BUTTON_HEADER_CTX(BCONTEXT_MATERIAL, ICON_MATERIAL, N_("Material"));
+	BUTTON_HEADER_CTX(BCONTEXT_TEXTURE, ICON_TEXTURE, N_("Textures"));
+	BUTTON_HEADER_CTX(BCONTEXT_PARTICLE, ICON_PARTICLES, N_("Particles"));
+	BUTTON_HEADER_CTX(BCONTEXT_PHYSICS, ICON_PHYSICS, N_("Physics"));
 
 #undef BUTTON_HEADER_CTX
 
diff --git a/source/blender/editors/space_file/file_draw.c b/source/blender/editors/space_file/file_draw.c
index 5f9b91e9cc2..b2b734159ff 100644
--- a/source/blender/editors/space_file/file_draw.c
+++ b/source/blender/editors/space_file/file_draw.c
@@ -50,6 +50,7 @@
 #include "BKE_main.h"
 
 #include "BLF_api.h"
+#include "BLF_translation.h"
 
 #include "IMB_imbuf_types.h"
  
@@ -181,7 +182,7 @@ void file_draw_buttons(const bContext *C, ARegion *ar)
 		but = uiDefButTextO(block, TEX, "FILE_OT_directory", 0, "",
 				 min_x, line1_y, line1_w-chan_offs, btn_h, 
 				 params->dir, 0.0, (float)FILE_MAX-1, 0, 0, 
-				 "File path");
+				 UI_translate_do_tooltip(N_("File path")));
 		uiButSetCompleteFunc(but, autocomplete_directory, NULL);
 		uiButSetFlag(but, UI_BUT_NO_UTF8);
 
@@ -189,7 +190,7 @@ void file_draw_buttons(const bContext *C, ARegion *ar)
 			but = uiDefBut(block, TEX, B_FS_FILENAME, "",
 					 min_x, line2_y, line2_w-chan_offs, btn_h,
 					 params->file, 0.0, (float)FILE_MAXFILE-1, 0, 0,
-					 overwrite_alert ?"File name, overwrite existing" : "File name");
+					 UI_translate_do_tooltip(overwrite_alert ?N_("File name, overwrite existing") : N_("File name")));
 			uiButSetCompleteFunc(but, autocomplete_file, NULL);
 			uiButSetFlag(but, UI_BUT_NO_UTF8);
 
@@ -209,13 +210,13 @@ void file_draw_buttons(const bContext *C, ARegion *ar)
 		but = uiDefIconButO(block, BUT, "FILE_OT_filenum", 0, ICON_ZOOMOUT,
 				min_x + line2_w + separator - chan_offs, line2_y, 
 				btn_fn_w, btn_h, 
-				"Decrement the filename number");    
+				UI_translate_do_tooltip(N_("Decrement the filename number")));    
 		RNA_int_set(uiButGetOperatorPtrRNA(but), "increment", -1); 
 	
 		but = uiDefIconButO(block, BUT, "FILE_OT_filenum", 0, ICON_ZOOMIN, 
 				min_x + line2_w + separator + btn_fn_w - chan_offs, line2_y, 
 				btn_fn_w, btn_h, 
-				"Increment the filename number");    
+				UI_translate_do_tooltip(N_("Increment the filename number")));    
 		RNA_int_set(uiButGetOperatorPtrRNA(but), "increment", 1); 
 		uiBlockEndAlign(block);
 	}
@@ -226,9 +227,9 @@ void file_draw_buttons(const bContext *C, ARegion *ar)
 		uiDefButO(block, BUT, "FILE_OT_execute", WM_OP_EXEC_REGION_WIN, params->title,
 			max_x - loadbutton, line1_y, loadbutton, btn_h, 
 			params->title);
-		uiDefButO(block, BUT, "FILE_OT_cancel", WM_OP_EXEC_REGION_WIN, "Cancel",
+		uiDefButO(block, BUT, "FILE_OT_cancel", WM_OP_EXEC_REGION_WIN, UI_translate_do_iface(N_("Cancel")),
 			max_x - loadbutton, line2_y, loadbutton, btn_h, 
-			"Cancel");
+			UI_translate_do_tooltip(N_("Cancel")));
 	}
 	
 	uiEndBlock(C, block);
@@ -295,7 +296,7 @@ static void file_draw_icon(uiBlock *block, char *path, int sx, int sy, int icon,
 
 static void file_draw_string(int sx, int sy, const char* string, float width, int height, short align)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiFontStyle fs = style->widgetlabel;
 	rcti rect;
 	char fname[FILE_MAXFILE];
diff --git a/source/blender/editors/space_file/file_panels.c b/source/blender/editors/space_file/file_panels.c
index 959b1ddf1b5..37dce293d77 100644
--- a/source/blender/editors/space_file/file_panels.c
+++ b/source/blender/editors/space_file/file_panels.c
@@ -37,6 +37,8 @@
 #include "BLI_blenlib.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
 #include "DNA_userdef_types.h"
@@ -144,7 +146,7 @@ static void file_panel_bookmarks(const bContext *C, Panel *pa)
 
 	if(sfile) {
 		row= uiLayoutRow(pa->layout, 0);
-		uiItemO(row, "Add", ICON_ZOOMIN, "file.bookmark_add");
+		uiItemO(row, UI_translate_do_iface(N_("Add")), ICON_ZOOMIN, "file.bookmark_add");
 		uiItemL(row, NULL, ICON_NONE);
 
 		file_panel_category(C, pa, FS_CATEGORY_BOOKMARKS, &sfile->bookmarknr, ICON_BOOKMARKS, 1, 0);
diff --git a/source/blender/editors/space_file/filesel.c b/source/blender/editors/space_file/filesel.c
index a8e7e08a7e0..1e113abfcd2 100644
--- a/source/blender/editors/space_file/filesel.c
+++ b/source/blender/editors/space_file/filesel.c
@@ -403,7 +403,7 @@ float file_shorten_string(char* string, float w, int front)
 
 float file_string_width(const char* str)
 {
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiStyleFontSet(&style->widget);
 	return BLF_width(style->widget.uifont_id, str);
 }
@@ -413,12 +413,12 @@ float file_font_pointsize(void)
 #if 0
 	float s;
 	char tmp[2] = "X";
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiStyleFontSet(&style->widget);
 	s = BLF_height(style->widget.uifont_id, tmp);
 	return style->widget.points;
 #else
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	uiStyleFontSet(&style->widget);
 	return style->widget.points * UI_DPI_FAC;
 #endif
diff --git a/source/blender/editors/space_graph/CMakeLists.txt b/source/blender/editors/space_graph/CMakeLists.txt
index 80205ad5564..28383b29b36 100644
--- a/source/blender/editors/space_graph/CMakeLists.txt
+++ b/source/blender/editors/space_graph/CMakeLists.txt
@@ -21,6 +21,7 @@
 
 set(INC
 	../include
+	../../blenfont
 	../../blenkernel
 	../../blenlib
 	../../blenloader
diff --git a/source/blender/editors/space_graph/SConscript b/source/blender/editors/space_graph/SConscript
index 75d0927192b..fe8846d2c30 100644
--- a/source/blender/editors/space_graph/SConscript
+++ b/source/blender/editors/space_graph/SConscript
@@ -3,7 +3,7 @@ Import ('env')
 
 sources = env.Glob('*.c')
 
-incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf'
+incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf'
 incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
 incs += ' #/intern/audaspace/intern ../../blenloader'
 
diff --git a/source/blender/editors/space_graph/graph_buttons.c b/source/blender/editors/space_graph/graph_buttons.c
index ffb43b753af..28fd1cd3304 100644
--- a/source/blender/editors/space_graph/graph_buttons.c
+++ b/source/blender/editors/space_graph/graph_buttons.c
@@ -46,6 +46,8 @@
 #include "BLI_rand.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_depsgraph.h"
 #include "BKE_fcurve.h"
@@ -750,7 +752,8 @@ static void graph_panel_modifiers(const bContext *C, Panel *pa)
 		block= uiLayoutGetBlock(row);
 		
 		// XXX for now, this will be a operator button which calls a 'add modifier' operator
-		uiDefButO(block, BUT, "GRAPH_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, "Add Modifier", 10, 0, 150, 20, "Adds a new F-Curve Modifier for the active F-Curve");
+		uiDefButO(block, BUT, "GRAPH_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, UI_translate_do_iface(N_("Add Modifier")), 10, 0, 150, 20,
+				UI_translate_do_tooltip(N_("Adds a new F-Curve Modifier for the active F-Curve")));
 		
 		/* copy/paste (as sub-row)*/
 		row= uiLayoutRow(row, 1);
diff --git a/source/blender/editors/space_info/space_info.c b/source/blender/editors/space_info/space_info.c
index bd2e8077eab..75e13b24ede 100644
--- a/source/blender/editors/space_info/space_info.c
+++ b/source/blender/editors/space_info/space_info.c
@@ -41,6 +41,8 @@
 #include "BLI_rand.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_global.h"
 #include "BKE_screen.h"
@@ -278,7 +280,7 @@ static void recent_files_menu_draw(const bContext *UNUSED(C), Menu *menu)
 			uiItemStringO(layout, BLI_path_basename(recent->filepath), ICON_FILE_BLEND, "WM_OT_open_mainfile", "filepath", recent->filepath);
 		}
 	} else {
-		uiItemL(layout, "No Recent Files", ICON_NONE);
+		uiItemL(layout, UI_translate_do_iface(N_("No Recent Files")), ICON_NONE);
 	}
 }
 
diff --git a/source/blender/editors/space_logic/CMakeLists.txt b/source/blender/editors/space_logic/CMakeLists.txt
index 44471902040..f4bb255e11f 100644
--- a/source/blender/editors/space_logic/CMakeLists.txt
+++ b/source/blender/editors/space_logic/CMakeLists.txt
@@ -21,10 +21,11 @@
 
 set(INC
 	../include
-	../interface
+	../../blenfont
 	../../blenkernel
 	../../blenlib
 	../../blenloader
+	../../editors/interface
 	../../makesdna
 	../../makesrna
 	../../windowmanager
diff --git a/source/blender/editors/space_logic/logic_window.c b/source/blender/editors/space_logic/logic_window.c
index 00f8f488b3c..3a4371e8bb9 100644
--- a/source/blender/editors/space_logic/logic_window.c
+++ b/source/blender/editors/space_logic/logic_window.c
@@ -4548,7 +4548,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
 	/* ****************** Controllers ****************** */
 	
 	xco= 420; yco= 170; width= 300;
-	layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first);
+	layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, UI_GetStyle());
 	row = uiLayoutRow(layout, 1);
 	
 	uiDefBlockBut(block, controller_menu, NULL, "Controllers", xco-10, yco, 300, UI_UNIT_Y, "");		/* replace this with uiLayout stuff later */
@@ -4651,7 +4651,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
 	/* ****************** Sensors ****************** */
 	
 	xco= 10; yco= 170; width= 340;
-	layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first);
+	layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, UI_GetStyle());
 	row = uiLayoutRow(layout, 1);
 	
 	uiDefBlockBut(block, sensor_menu, NULL, "Sensors", xco-10, yco, 300, UI_UNIT_Y, "");		/* replace this with uiLayout stuff later */
@@ -4717,7 +4717,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
 	/* ****************** Actuators ****************** */
 	
 	xco= 800; yco= 170; width= 340;
-	layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first);
+	layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, UI_GetStyle());
 	row = uiLayoutRow(layout, 1);
 	
 	uiDefBlockBut(block, actuator_menu, NULL, "Actuators", xco-10, yco, 300, UI_UNIT_Y, "");		/* replace this with uiLayout stuff later */
diff --git a/source/blender/editors/space_nla/CMakeLists.txt b/source/blender/editors/space_nla/CMakeLists.txt
index b05d157365d..819e80d7b2e 100644
--- a/source/blender/editors/space_nla/CMakeLists.txt
+++ b/source/blender/editors/space_nla/CMakeLists.txt
@@ -21,6 +21,7 @@
 
 set(INC
 	../include
+	../../blenfont
 	../../blenkernel
 	../../blenlib
 	../../blenloader
diff --git a/source/blender/editors/space_nla/SConscript b/source/blender/editors/space_nla/SConscript
index 51ce829ed8d..6738f3380b4 100644
--- a/source/blender/editors/space_nla/SConscript
+++ b/source/blender/editors/space_nla/SConscript
@@ -3,7 +3,7 @@ Import ('env')
 
 sources = env.Glob('*.c')
 
-incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf'
+incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf'
 incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include ../../blenloader'
 
 env.BlenderLib ( 'bf_editors_space_nla', sources, Split(incs), [], libtype=['core'], priority=[85] )
diff --git a/source/blender/editors/space_nla/nla_buttons.c b/source/blender/editors/space_nla/nla_buttons.c
index 4392e49e5d7..5e1f2745559 100644
--- a/source/blender/editors/space_nla/nla_buttons.c
+++ b/source/blender/editors/space_nla/nla_buttons.c
@@ -45,6 +45,8 @@
 #include "BLI_editVert.h"
 #include "BLI_rand.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_nla.h"
 #include "BKE_context.h"
 #include "BKE_screen.h"
@@ -446,7 +448,8 @@ static void nla_panel_modifiers(const bContext *C, Panel *pa)
 		
 		// XXX for now, this will be a operator button which calls a temporary 'add modifier' operator
 		// FIXME: we need to set the only-active property so that this will only add modifiers for the active strip (not all selected)
-		uiDefButO(block, BUT, "NLA_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, "Add Modifier", 10, 0, 150, 20, "Adds a new F-Modifier for the active NLA Strip");
+		uiDefButO(block, BUT, "NLA_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, UI_translate_do_iface(N_("Add Modifier")), 10, 0, 150, 20,
+				UI_translate_do_tooltip(N_("Adds a new F-Modifier for the active NLA Strip")));
 		
 		/* copy/paste (as sub-row)*/
 		row= uiLayoutRow(row, 1);
diff --git a/source/blender/editors/space_node/node_draw.c b/source/blender/editors/space_node/node_draw.c
index c1b114d5436..e713ed5a678 100644
--- a/source/blender/editors/space_node/node_draw.c
+++ b/source/blender/editors/space_node/node_draw.c
@@ -303,7 +303,7 @@ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node)
 		RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
 		
 		layout= uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL,
-							  locx+NODE_DYS, dy, node->butr.xmax, NODE_DY, U.uistyles.first);
+							  locx+NODE_DYS, dy, node->butr.xmax, NODE_DY, UI_GetStyle());
 		
 		node->typeinfo->uifunc(layout, (bContext *)C, &ptr);
 		
diff --git a/source/blender/editors/space_node/node_header.c b/source/blender/editors/space_node/node_header.c
index 7077f4a7497..996e05afdef 100644
--- a/source/blender/editors/space_node/node_header.c
+++ b/source/blender/editors/space_node/node_header.c
@@ -44,6 +44,8 @@
 #include "BLI_blenlib.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_global.h"
 #include "BKE_screen.h"
@@ -216,6 +218,7 @@ static void node_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass)
 	}
 }
 
+#define IFACE_(msgid) UI_translate_do_iface(msgid)
 static void node_menu_add(const bContext *C, Menu *menu)
 {
 	SpaceNode *snode= CTX_wm_space_node(C);
@@ -225,39 +228,40 @@ static void node_menu_add(const bContext *C, Menu *menu)
 		uiLayoutSetActive(layout, 0);
 
 	if(snode->treetype==NTREE_SHADER) {
-		uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
-		uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
-		uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
-		uiItemMenuF(layout, "Vector", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
-		uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
-		uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
-		uiItemMenuF(layout, "Dynamic", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_DYNAMIC));
-		uiItemMenuF(layout, "Layout", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT));
+		uiItemMenuF(layout, IFACE_(N_("Input")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
+		uiItemMenuF(layout, IFACE_(N_("Output")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
+		uiItemMenuF(layout, IFACE_(N_("Color")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
+		uiItemMenuF(layout, IFACE_(N_("Vector")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
+		uiItemMenuF(layout, IFACE_(N_("Convertor")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
+		uiItemMenuF(layout, IFACE_(N_("Group")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
+		uiItemMenuF(layout, IFACE_(N_("Dynamic")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_DYNAMIC));
+		uiItemMenuF(layout, IFACE_(N_("Layout")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT));
 	}
 	else if(snode->treetype==NTREE_COMPOSIT) {
-		uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
-		uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
-		uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
-		uiItemMenuF(layout, "Vector", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
-		uiItemMenuF(layout, "Filter", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_FILTER));
-		uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
-		uiItemMenuF(layout, "Matte", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_MATTE));
-		uiItemMenuF(layout, "Distort", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
-		uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
-		uiItemMenuF(layout, "Layout", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT));
+		uiItemMenuF(layout, IFACE_(N_("Input")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
+		uiItemMenuF(layout, IFACE_(N_("Output")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
+		uiItemMenuF(layout, IFACE_(N_("Color")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
+		uiItemMenuF(layout, IFACE_(N_("Vector")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
+		uiItemMenuF(layout, IFACE_(N_("Filter")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_FILTER));
+		uiItemMenuF(layout, IFACE_(N_("Convertor")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
+		uiItemMenuF(layout, IFACE_(N_("Matte")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_MATTE));
+		uiItemMenuF(layout, IFACE_(N_("Distort")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
+		uiItemMenuF(layout, IFACE_(N_("Group")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
+		uiItemMenuF(layout, IFACE_(N_("Layout")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT));
 	}
 	else if(snode->treetype==NTREE_TEXTURE) {
-		uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
-		uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
-		uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
-		uiItemMenuF(layout, "Patterns", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_PATTERN));
-		uiItemMenuF(layout, "Textures", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_TEXTURE));
-		uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
-		uiItemMenuF(layout, "Distort", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
-		uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
-		uiItemMenuF(layout, "Layout", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT));
+		uiItemMenuF(layout, IFACE_(N_("Input")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
+		uiItemMenuF(layout, IFACE_(N_("Output")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
+		uiItemMenuF(layout, IFACE_(N_("Color")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
+		uiItemMenuF(layout, IFACE_(N_("Patterns")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_PATTERN));
+		uiItemMenuF(layout, IFACE_(N_("Textures")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_TEXTURE));
+		uiItemMenuF(layout, IFACE_(N_("Convertor")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
+		uiItemMenuF(layout, IFACE_(N_("Distort")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
+		uiItemMenuF(layout, IFACE_(N_("Group")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
+		uiItemMenuF(layout, IFACE_(N_("Layout")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT));
 	}
 }
+#undef IFACE_
 
 void node_menus_register(void)
 {
diff --git a/source/blender/editors/space_view3d/view3d_header.c b/source/blender/editors/space_view3d/view3d_header.c
index 980e27ce116..0776ca752a9 100644
--- a/source/blender/editors/space_view3d/view3d_header.c
+++ b/source/blender/editors/space_view3d/view3d_header.c
@@ -47,6 +47,8 @@
 #include "BLI_editVert.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_depsgraph.h"
 #include "BKE_effect.h"
@@ -269,16 +271,29 @@ void VIEW3D_OT_layers(wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "toggle", 1, "Toggle", "Toggle the layer");
 }
 
+static int modeselect_addmode(char *str, const char *title, int id, int icon)
+{
+	static char formatstr[] = "|%s %%x%d %%i%d";
+
+	if(UI_translate_iface())
+		return sprintf(str, formatstr, BLF_gettext(title), id, icon);
+	else
+		return sprintf(str, formatstr, title, id, icon);
+}
+
 static char *view3d_modeselect_pup(Scene *scene)
 {
 	Object *ob= OBACT;
 	static char string[256];
-	static char formatstr[] = "|%s %%x%d %%i%d";
+	const char *title= N_("Mode: %%t");
 	char *str = string;
 
-	str += sprintf(str, "Mode: %%t");
+	if(U.transopts&USER_TR_IFACE)
+		title= BLF_gettext(title);
+
+	sprintf(str, title);
 	
-	str += sprintf(str, formatstr, "Object Mode", OB_MODE_OBJECT, ICON_OBJECT_DATA);
+	str += modeselect_addmode(str, N_("Object Mode"), OB_MODE_OBJECT, ICON_OBJECT_DATA);
 	
 	if(ob==NULL || ob->data==NULL) return string;
 	if(ob->id.lib) return string;
@@ -289,31 +304,31 @@ static char *view3d_modeselect_pup(Scene *scene)
 			|| (ob->type == OB_CURVE) || (ob->type == OB_SURF) || (ob->type == OB_FONT)
 			|| (ob->type == OB_MBALL) || (ob->type == OB_LATTICE))) {
 			
-			str += sprintf(str, formatstr, "Edit Mode", OB_MODE_EDIT, ICON_EDITMODE_HLT);
+			str += modeselect_addmode(str, N_("Edit Mode"), OB_MODE_EDIT, ICON_EDITMODE_HLT);
 		}
 		else if (ob->type == OB_ARMATURE) {
 			if (ob->mode & OB_MODE_POSE)
-				str += sprintf(str, formatstr, "Edit Mode", OB_MODE_EDIT|OB_MODE_POSE, ICON_EDITMODE_HLT);
+				str += modeselect_addmode(str, N_("Edit Mode"), OB_MODE_EDIT|OB_MODE_POSE, ICON_EDITMODE_HLT);
 			else
-				str += sprintf(str, formatstr, "Edit Mode", OB_MODE_EDIT, ICON_EDITMODE_HLT);
+				str += modeselect_addmode(str, N_("Edit Mode"), OB_MODE_EDIT, ICON_EDITMODE_HLT);
 		}
 
 		if (ob->type == OB_MESH) {
 
-			str += sprintf(str, formatstr, "Sculpt Mode", OB_MODE_SCULPT, ICON_SCULPTMODE_HLT);
-			str += sprintf(str, formatstr, "Vertex Paint", OB_MODE_VERTEX_PAINT, ICON_VPAINT_HLT);
-			str += sprintf(str, formatstr, "Texture Paint", OB_MODE_TEXTURE_PAINT, ICON_TPAINT_HLT);
-			str += sprintf(str, formatstr, "Weight Paint", OB_MODE_WEIGHT_PAINT, ICON_WPAINT_HLT);
+			str += modeselect_addmode(str, N_("Sculpt Mode"), OB_MODE_SCULPT, ICON_SCULPTMODE_HLT);
+			str += modeselect_addmode(str, N_("Vertex Paint"), OB_MODE_VERTEX_PAINT, ICON_VPAINT_HLT);
+			str += modeselect_addmode(str, N_("Texture Paint"), OB_MODE_TEXTURE_PAINT, ICON_TPAINT_HLT);
+			str += modeselect_addmode(str, N_("Weight Paint"), OB_MODE_WEIGHT_PAINT, ICON_WPAINT_HLT);
 		}
 	}
 		
 	/* if active object is an armature */
 	if (ob->type==OB_ARMATURE) {
-		str += sprintf(str, formatstr, "Pose Mode", OB_MODE_POSE, ICON_POSE_HLT);
+		str += modeselect_addmode(str, N_("Pose Mode"), OB_MODE_POSE, ICON_POSE_HLT);
 	}
 
 	if (ob->particlesystem.first || modifiers_findByType(ob, eModifierType_Cloth) || modifiers_findByType(ob, eModifierType_Softbody)) {
-		str += sprintf(str, formatstr, "Particle Mode", OB_MODE_PARTICLE_EDIT, ICON_PARTICLEMODE);
+		str += modeselect_addmode(str, N_("Particle Mode"), OB_MODE_PARTICLE_EDIT, ICON_PARTICLEMODE);
 	}
 	(void)str;
 	return (string);
@@ -455,6 +470,7 @@ void uiTemplateEditModeSelection(uiLayout *layout, struct bContext *C)
 	}
 }
 
+#define TIP_(msgid) UI_translate_do_tooltip(msgid)
 void uiTemplateHeader3D(uiLayout *layout, struct bContext *C)
 {
 	bScreen *screen= CTX_wm_screen(C);
@@ -488,7 +504,7 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C)
 
 	uiBlockBeginAlign(block);
 	uiDefIconTextButS(block, MENU, B_MODESELECT, object_mode_icon(v3d->modeselect), view3d_modeselect_pup(scene) , 
-			  0,0,126 * dpi_fac, UI_UNIT_Y, &(v3d->modeselect), 0, 0, 0, 0, "Mode");
+			  0,0,126 * dpi_fac, UI_UNIT_Y, &(v3d->modeselect), 0, 0, 0, 0, TIP_(N_("Mode")));
 	uiBlockEndAlign(block);
 	
 	/* Draw type */
@@ -522,11 +538,11 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C)
 		block= uiLayoutGetBlock(row);
 		
 		if(v3d->twflag & V3D_USE_MANIPULATOR) {
-			but= uiDefIconButBitC(block, TOG, V3D_MANIP_TRANSLATE, B_MAN_TRANS, ICON_MAN_TRANS, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, "Translate manipulator mode");
+			but= uiDefIconButBitC(block, TOG, V3D_MANIP_TRANSLATE, B_MAN_TRANS, ICON_MAN_TRANS, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, TIP_(N_("Translate manipulator mode")));
 			uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */
-			but= uiDefIconButBitC(block, TOG, V3D_MANIP_ROTATE, B_MAN_ROT, ICON_MAN_ROT, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, "Rotate manipulator mode");
+			but= uiDefIconButBitC(block, TOG, V3D_MANIP_ROTATE, B_MAN_ROT, ICON_MAN_ROT, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, TIP_(N_("Rotate manipulator mode")));
 			uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */
-			but= uiDefIconButBitC(block, TOG, V3D_MANIP_SCALE, B_MAN_SCALE, ICON_MAN_SCALE, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, "Scale manipulator mode");
+			but= uiDefIconButBitC(block, TOG, V3D_MANIP_SCALE, B_MAN_SCALE, ICON_MAN_SCALE, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, TIP_(N_("Scale manipulator mode")));
 			uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */
 		}
 			
@@ -534,8 +550,8 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C)
 			v3d->twmode = 0;
 		}
 			
-		str_menu = BIF_menustringTransformOrientation(C, "Orientation");
-		but= uiDefButC(block, MENU, B_MAN_MODE, str_menu,0,0,70 * dpi_fac, UI_UNIT_Y, &v3d->twmode, 0, 0, 0, 0, "Transform Orientation");
+		str_menu = BIF_menustringTransformOrientation(C, N_("Orientation"));
+		but= uiDefButC(block, MENU, B_MAN_MODE, str_menu,0,0,70 * dpi_fac, UI_UNIT_Y, &v3d->twmode, 0, 0, 0, 0, TIP_(N_("Transform Orientation")));
 		uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */
 		MEM_freeN((void *)str_menu);
 	}
@@ -555,4 +571,4 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C)
 	
 	uiTemplateEditModeSelection(layout, C);
 }
-
+#undef TIP_
diff --git a/source/blender/editors/space_view3d/view3d_toolbar.c b/source/blender/editors/space_view3d/view3d_toolbar.c
index a2aed67821d..ddea89e1cdb 100644
--- a/source/blender/editors/space_view3d/view3d_toolbar.c
+++ b/source/blender/editors/space_view3d/view3d_toolbar.c
@@ -48,6 +48,8 @@
 #include "BLI_utildefines.h"
 #include "BLI_ghash.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_context.h"
 #include "BKE_idprop.h"
 #include "BKE_global.h"
@@ -80,7 +82,7 @@ static void view3d_panel_operator_redo_header(const bContext *C, Panel *pa)
 	wmOperator *op= WM_operator_last_redo(C);
 
 	if(op) BLI_strncpy(pa->drawname, op->type->name, sizeof(pa->drawname));
-	else BLI_strncpy(pa->drawname, "Operator", sizeof(pa->drawname));
+	else BLI_strncpy(pa->drawname, N_("Operator"), sizeof(pa->drawname));
 }
 
 static void view3d_panel_operator_redo_operator(const bContext *C, Panel *pa, wmOperator *op)
diff --git a/source/blender/editors/transform/CMakeLists.txt b/source/blender/editors/transform/CMakeLists.txt
index e44cc1f5df3..c4305ed6a9f 100644
--- a/source/blender/editors/transform/CMakeLists.txt
+++ b/source/blender/editors/transform/CMakeLists.txt
@@ -21,6 +21,7 @@
 
 set(INC
 	../include
+	../../blenfont
 	../../blenkernel
 	../../blenlib
 	../../blenloader
diff --git a/source/blender/editors/transform/SConscript b/source/blender/editors/transform/SConscript
index edc2156a07b..f2d5baecfb3 100644
--- a/source/blender/editors/transform/SConscript
+++ b/source/blender/editors/transform/SConscript
@@ -3,7 +3,7 @@ Import ('env')
 
 sources = env.Glob('*.c')
 
-incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
+incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
 incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
 incs += ' ../../render/extern/include'
 incs += ' ../../gpu ../../makesrna ../../blenloader'
diff --git a/source/blender/editors/transform/transform_orientations.c b/source/blender/editors/transform/transform_orientations.c
index 7556c5ae110..cd4cbc77c49 100644
--- a/source/blender/editors/transform/transform_orientations.c
+++ b/source/blender/editors/transform/transform_orientations.c
@@ -50,6 +50,8 @@
 #include "BLI_editVert.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 //#include "BIF_editmesh.h"
 //#include "BIF_interface.h"
 //#include "BIF_space.h"
@@ -60,6 +62,8 @@
 
 #include "RNA_define.h"
 
+#include "UI_interface.h"
+
 #include "transform.h"
 
 /* *********************** TransSpace ************************** */
@@ -406,14 +410,18 @@ EnumPropertyItem *BIF_enumTransformOrientation(bContext *C)
 }
 
 const char * BIF_menustringTransformOrientation(const bContext *C, const char *title) {
-	char menu[] = "%t|Global%x0|Local%x1|Gimbal%x4|Normal%x2|View%x3";
+	const char* menu = N_("%t|Global%x0|Local%x1|Gimbal%x4|Normal%x2|View%x3");
 	ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces;
 	TransformOrientation *ts;
 	int i = V3D_MANIP_CUSTOM;
 	char *str_menu, *p;
+
+	if(UI_translate_iface()) {
+		title= BLF_gettext(title);
+		menu= BLF_gettext(menu);
+	}
 	
-	
-	str_menu = MEM_callocN(strlen(menu) + strlen(title) + 1 + 40 * BIF_countTransformOrientation(C), "UserTransSpace from matrix");
+	str_menu = MEM_callocN(strlen(menu) + strlen(title) + 1 + 40 * BIF_countTransformOrientation(C), UI_translate_do_tooltip(N_("UserTransSpace from matrix")));
 	p = str_menu;
 	
 	p += sprintf(str_menu, "%s", title);
diff --git a/source/blender/makesdna/DNA_userdef_types.h b/source/blender/makesdna/DNA_userdef_types.h
index d3ac09dc812..05b16f869a8 100644
--- a/source/blender/makesdna/DNA_userdef_types.h
+++ b/source/blender/makesdna/DNA_userdef_types.h
@@ -510,8 +510,8 @@ extern UserDef U; /* from blenkernel blender.c */
 
 /* transopts */
 #define	USER_TR_TOOLTIPS		(1 << 0)
-#define	USER_TR_BUTTONS			(1 << 1)
-#define USER_TR_MENUS			(1 << 2)
+#define	USER_TR_IFACE			(1 << 1)
+/*#define USER_TR_MENUS			(1 << 2)	deprecated*/
 /*#define USER_TR_FILESELECT	(1 << 3)	deprecated*/
 /*#define USER_TR_TEXTEDIT		(1 << 4)	deprecated*/
 #define USER_DOTRANSLATE		(1 << 5)
diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h
index 8af4fe7b76b..26bae68d5a4 100644
--- a/source/blender/makesrna/RNA_access.h
+++ b/source/blender/makesrna/RNA_access.h
@@ -49,7 +49,10 @@ struct Scene;
 extern BlenderRNA BLENDER_RNA;
 extern StructRNA RNA_Action;
 extern StructRNA RNA_ActionConstraint;
+extern StructRNA RNA_ActionFCurves;
 extern StructRNA RNA_ActionGroup;
+extern StructRNA RNA_ActionGroups;
+extern StructRNA RNA_ActionPoseMarkers;
 extern StructRNA RNA_Actuator;
 extern StructRNA RNA_ActuatorSensor;
 extern StructRNA RNA_Addon;
@@ -190,6 +193,7 @@ extern StructRNA RNA_DelaySensor;
 extern StructRNA RNA_DisplaceModifier;
 extern StructRNA RNA_DistortedNoiseTexture;
 extern StructRNA RNA_DomainFluidSettings;
+extern StructRNA RNA_DopeSheet;
 extern StructRNA RNA_Driver;
 extern StructRNA RNA_DriverTarget;
 extern StructRNA RNA_DriverVariable;
@@ -260,11 +264,13 @@ extern StructRNA RNA_Key;
 extern StructRNA RNA_KeyConfig;
 extern StructRNA RNA_KeyMap;
 extern StructRNA RNA_KeyMapItem;
+extern StructRNA RNA_KeyMapItems;
 extern StructRNA RNA_KeyboardSensor;
 extern StructRNA RNA_Keyframe;
 extern StructRNA RNA_KeyingSet;
 extern StructRNA RNA_KeyingSetInfo;
 extern StructRNA RNA_KeyingSetPath;
+extern StructRNA RNA_KeyingSetsAll;
 extern StructRNA RNA_KinematicConstraint;
 extern StructRNA RNA_Lamp;
 extern StructRNA RNA_LampSkySettings;
@@ -552,6 +558,7 @@ extern StructRNA RNA_UnknownType;
 extern StructRNA RNA_UserPreferences;
 extern StructRNA RNA_UserPreferencesEdit;
 extern StructRNA RNA_UserPreferencesFilePaths;
+extern StructRNA RNA_UserPreferencesInput;
 extern StructRNA RNA_UserPreferencesSystem;
 extern StructRNA RNA_UserPreferencesView;
 extern StructRNA RNA_UserSolidLight;
@@ -573,13 +580,13 @@ extern StructRNA RNA_WipeSequence;
 extern StructRNA RNA_WoodTexture;
 extern StructRNA RNA_World;
 extern StructRNA RNA_WorldAmbientOcclusion;
+extern StructRNA RNA_WorldLighting;
 extern StructRNA RNA_WorldMistSettings;
 extern StructRNA RNA_WorldStarsSettings;
 extern StructRNA RNA_WorldTextureSlot;
 extern StructRNA RNA_XnorController;
 extern StructRNA RNA_XorController;
 
-
 /* Pointer
  *
  * These functions will fill in RNA pointers, this can be done in three ways:
@@ -689,6 +696,7 @@ int RNA_enum_name(EnumPropertyItem *item, const int value, const char **name);
 int RNA_enum_description(EnumPropertyItem *item, const int value, const char **description);
 
 void RNA_property_enum_items(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free);
+void RNA_property_enum_items_gettexted(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free);
 int RNA_property_enum_value(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const char *identifier, int *value);
 int RNA_property_enum_identifier(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **identifier);
 int RNA_property_enum_name(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **name);
diff --git a/source/blender/makesrna/SConscript b/source/blender/makesrna/SConscript
index 10b20fc795a..d0002eda30b 100644
--- a/source/blender/makesrna/SConscript
+++ b/source/blender/makesrna/SConscript
@@ -62,4 +62,7 @@ if env['OURPLATFORM'] == 'linux':
 if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'):
     incs += ' ' + env['BF_PTHREADS_INC']
 
+if env['WITH_BF_INTERNATIONAL']:
+    defs.append('INTERNATIONAL')
+
 env.BlenderLib ( 'bf_rna', objs, Split(incs), defines=defs, libtype=['core','player'], priority = [165,20] )
diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt
index c2b46a3b69a..966bc8f100c 100644
--- a/source/blender/makesrna/intern/CMakeLists.txt
+++ b/source/blender/makesrna/intern/CMakeLists.txt
@@ -219,6 +219,10 @@ if(WITH_OPENCOLLADA)
 	add_definitions(-DWITH_COLLADA)
 endif()
 
+if(WITH_INTERNATIONAL)
+	add_definitions(-DINTERNATIONAL)
+endif()
+
 # Build makesrna executable
 blender_include_dirs(
 	.
diff --git a/source/blender/makesrna/intern/SConscript b/source/blender/makesrna/intern/SConscript
index 5c2580e4b90..ef05875fe86 100644
--- a/source/blender/makesrna/intern/SConscript
+++ b/source/blender/makesrna/intern/SConscript
@@ -98,6 +98,9 @@ if env['OURPLATFORM'] == 'linux':
 if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'):
     incs += ' ' + env['BF_PTHREADS_INC']
 
+if env['WITH_BF_INTERNATIONAL']:
+    defs.append('INTERNATIONAL')
+
 makesrna_tool.Append(CPPDEFINES=defs)
 
 makesrna_tool.Append (CPPPATH = Split(incs))
diff --git a/source/blender/makesrna/intern/rna_access.c b/source/blender/makesrna/intern/rna_access.c
index 5dad7112eb9..b7709416a75 100644
--- a/source/blender/makesrna/intern/rna_access.c
+++ b/source/blender/makesrna/intern/rna_access.c
@@ -43,6 +43,9 @@
 #include "BLI_dynstr.h"
 #include "BLI_ghash.h"
 
+#include "BLF_api.h"
+#include "BLF_translation.h"
+
 #include "BKE_animsys.h"
 #include "BKE_context.h"
 #include "BKE_idprop.h"
@@ -449,8 +452,10 @@ static const char *rna_ensure_property_identifier(PropertyRNA *prop)
 
 static const char *rna_ensure_property_description(PropertyRNA *prop)
 {
+	const char *description= NULL;
+
 	if(prop->magic == RNA_MAGIC)
-		return prop->description;
+		description= prop->description;
 	else {
 		/* attempt to get the local ID values */
 		IDProperty *idp_ui= rna_idproperty_ui(prop);
@@ -458,19 +463,36 @@ static const char *rna_ensure_property_description(PropertyRNA *prop)
 		if(idp_ui) {
 			IDProperty *item= IDP_GetPropertyTypeFromGroup(idp_ui, "description", IDP_STRING);
 			if(item)
-				return IDP_String(item);
+				description= IDP_String(item);
 		}
 
-		return ((IDProperty*)prop)->name; /* XXX - not correct */
+		if(description == NULL)
+			description= ((IDProperty*)prop)->name; /* XXX - not correct */
 	}
+
+#ifdef INTERNATIONAL
+	if((U.transopts&USER_DOTRANSLATE) && (U.transopts&USER_TR_TOOLTIPS))
+		description= BLF_gettext(description);
+#endif
+
+	return description;
 }
 
 static const char *rna_ensure_property_name(PropertyRNA *prop)
 {
+	const char *name;
+
 	if(prop->magic == RNA_MAGIC)
-		return prop->name;
+		name= prop->name;
 	else
-		return ((IDProperty*)prop)->name;
+		name= ((IDProperty*)prop)->name;
+
+#ifdef INTERNATIONAL
+	if((U.transopts&USER_DOTRANSLATE) && (U.transopts&USER_TR_IFACE))
+		name= BLF_gettext(name);
+#endif
+
+	return name;
 }
 
 /* Structs */
@@ -1125,6 +1147,7 @@ void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, En
 
 			*totitem= tot;
 		}
+
 	}
 	else {
 		*item= eprop->item;
@@ -1133,6 +1156,45 @@ void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, En
 	}
 }
 
+void RNA_property_enum_items_gettexted(bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free)
+{
+	RNA_property_enum_items(C, ptr, prop, item, totitem, free);
+
+#ifdef INTERNATIONAL
+	if((U.transopts&USER_DOTRANSLATE) && (U.transopts&USER_TR_IFACE)) {
+		int i;
+		EnumPropertyItem *nitem;
+
+		if(*free) {
+			nitem= *item;
+		} else {
+			int totitem= 0;
+
+			/* count */
+			for(i=0; (*item)[i].identifier; i++)
+				totitem++;
+
+			nitem= MEM_callocN(sizeof(EnumPropertyItem)*(totitem+1), "enum_items_gettexted");
+
+			for(i=0; (*item)[i].identifier; i++)
+				nitem[i]= (*item)[i];
+
+			*free= 1;
+		}
+
+		for(i=0; nitem[i].identifier; i++) {
+			if( nitem[i].name )
+				nitem[i].name = BLF_gettext(nitem[i].name);
+			if( nitem[i].description )
+				nitem[i].description = BLF_gettext(nitem[i].description);
+		}
+
+		*item= nitem;
+	}
+#endif
+}
+
+
 int RNA_property_enum_value(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const char *identifier, int *value)
 {	
 	EnumPropertyItem *item, *item_array;
diff --git a/source/blender/makesrna/intern/rna_userdef.c b/source/blender/makesrna/intern/rna_userdef.c
index 7a5899afd73..b9a53acd6f4 100644
--- a/source/blender/makesrna/intern/rna_userdef.c
+++ b/source/blender/makesrna/intern/rna_userdef.c
@@ -44,6 +44,7 @@
 #include "WM_types.h"
 
 #include "BLI_utildefines.h"
+#include "BLF_translation.h"
 
 #include "BKE_sound.h"
 
@@ -76,6 +77,11 @@ static void rna_userdef_dpi_update(Main *bmain, Scene *scene, PointerRNA *ptr)
 	WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);	/* refresh region sizes */
 }
 
+static void rna_userdef_language_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr))
+{
+	BLF_lang_set(NULL);
+}
+
 static void rna_userdef_show_manipulator_update(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
 	UserDef *userdef = (UserDef *)ptr->data;
@@ -2463,30 +2469,35 @@ static void rna_def_userdef_system(BlenderRNA *brna)
 		{0, NULL, 0, NULL, NULL}};
 	
 		/* hardcoded here, could become dynamic somehow */
+	/* locale according to http://www.roseindia.net/tutorials/I18N/locales-list.shtml */
+	/* if you edit here, please also edit the source/blender/blenfont/intern/blf_lang.c 's locales */
 	static EnumPropertyItem language_items[] = {
-		{0, "ENGLISH", 0, "English", ""},
-		{1, "JAPANESE", 0, "Japanese", ""},
-		{2, "DUTCH", 0, "Dutch", ""},
-		{3, "ITALIAN", 0, "Italian", ""},
-		{4, "GERMAN", 0, "German", ""},
-		{5, "FINNISH", 0, "Finnish", ""},
-		{6, "SWEDISH", 0, "Swedish", ""},
-		{7, "FRENCH", 0, "French", ""},
-		{8, "SPANISH", 0, "Spanish", ""},
-		{9, "CATALAN", 0, "Catalan", ""},
-		{10, "CZECH", 0, "Czech", ""},
-		{11, "BRAZILIAN_PORTUGUESE", 0, "Brazilian Portuguese", ""},
-		{12, "SIMPLIFIED_CHINESE", 0, "Simplified Chinese", ""},
-		{13, "RUSSIAN", 0, "Russian", ""},
-		{14, "CROATIAN", 0, "Croatian", ""},
-		{15, "SERBIAN", 0, "Serbian", ""},
-		{16, "UKRAINIAN", 0, "Ukrainian", ""},
-		{17, "POLISH", 0, "Polish", ""},
-		{18, "ROMANIAN", 0, "Romanian", ""},
-		{19, "ARABIC", 0, "Arabic", ""},
-		{20, "BULGARIAN", 0, "Bulgarian", ""},
-		{21, "GREEK", 0, "Greek", ""},
-		{22, "KOREAN", 0, "Korean", ""},
+		{0, "DEFAULT", 0, N_("Default (Default)"), ""},
+		{1, "ENGLISH", 0, N_("English (English)"), "en_US"},
+		{2, "JAPANESE", 0, N_("Japanese (日本語)"), "ja_JP"},
+		{3, "DUTCH", 0, N_("Dutch (Nederlandse taal)"), "nl_NL"},
+		{4, "ITALIAN", 0, N_("Italian (Italiano)"), "it_IT"},
+		{5, "GERMAN", 0, N_("German (Deutsch)"), "de_DE"},
+		{6, "FINNISH", 0, N_("Finnish (Suomi)"), "fi_FI"},
+		{7, "SWEDISH", 0, N_("Swedish (Svenska)"), "sv_SE"},
+		{8, "FRENCH", 0, N_("French (Française)"), "fr_FR"},
+		{9, "SPANISH", 0, N_("Spanish (Español)"), "es_ES"},
+		{10, "CATALAN", 0, N_("Catalan (Català)"), "ca_AD"},
+		{11, "CZECH", 0, N_("Czech (Český)"), "cs_CZ"},
+		{12, "BRAZILIAN_PORTUGUESE", 0, N_("Brazilian Portuguese (Português do Brasil)"), "pt_BR"},
+		{13, "SIMPLIFIED_CHINESE", 0, N_("Simplified Chinese (简体中文)"), "zh_CN"},
+		{14, "TRADITIONAL_CHINESE", 0, N_("Traditional Chinese (繁體中文)"), "zh_TW"},
+		{15, "RUSSIAN", 0, N_("Russian (Русский)"), "ru_RU"},
+		{16, "CROATIAN", 0, N_("Croatian (Hrvatski)"), "hr_HR"},
+		{17, "SERBIAN", 0, N_("Serbian (Српском језику)"), "sr_RS"},
+		{18, "UKRAINIAN", 0, N_("Ukrainian (Український)"), "uk_UA"},
+		{19, "POLISH", 0, N_("Polish (Polski)"), "pl_PL"},
+		{20, "ROMANIAN", 0, N_("Romanian (Român)"), "ro_RO"},
+		{21, "ARABIC", 0, N_("Arabic (العربية)"), "ar_EG"},
+		{22, "BULGARIAN", 0, N_("Bulgarian (Български)"), "bg_BG"},
+		{23, "GREEK", 0, N_("Greek (Ελληνικά)"), "el_GR"},
+		{24, "KOREAN", 0, N_("Korean (한국 언어)"), "ko_KR"},
+		/*{25, "Nepali", 0, N_("Nepali (नेपाली)"), "ne_NP"},*/
 		{0, NULL, 0, NULL, NULL}};
 
 	srna= RNA_def_struct(brna, "UserPreferencesSystem", NULL);
@@ -2499,7 +2510,7 @@ static void rna_def_userdef_system(BlenderRNA *brna)
 	prop= RNA_def_property(srna, "use_international_fonts", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_DOTRANSLATE);
 	RNA_def_property_ui_text(prop, "International Fonts", "Use international fonts");
-	RNA_def_property_update(prop, 0, "rna_userdef_update");
+	RNA_def_property_update(prop, NC_WINDOW, "rna_userdef_language_update");
 
 	prop= RNA_def_property(srna, "dpi", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "dpi");
@@ -2522,21 +2533,16 @@ static void rna_def_userdef_system(BlenderRNA *brna)
 	prop= RNA_def_property(srna, "language", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_items(prop, language_items);
 	RNA_def_property_ui_text(prop, "Language", "Language use for translation");
-	RNA_def_property_update(prop, 0, "rna_userdef_update");
+	RNA_def_property_update(prop, NC_WINDOW, "rna_userdef_language_update");
 
 	prop= RNA_def_property(srna, "use_translate_tooltips", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_TOOLTIPS);
 	RNA_def_property_ui_text(prop, "Translate Tooltips", "Translate Tooltips");
 	RNA_def_property_update(prop, 0, "rna_userdef_update");
 
-	prop= RNA_def_property(srna, "use_translate_buttons", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_BUTTONS);
-	RNA_def_property_ui_text(prop, "Translate Buttons", "Translate button labels");
-	RNA_def_property_update(prop, 0, "rna_userdef_update");
-
-	prop= RNA_def_property(srna, "use_translate_toolbox", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_MENUS);
-	RNA_def_property_ui_text(prop, "Translate Toolbox", "Translate toolbox menu");
+	prop= RNA_def_property(srna, "use_translate_interface", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_IFACE);
+	RNA_def_property_ui_text(prop, "Translate Interface", "Translate Interface");
 	RNA_def_property_update(prop, 0, "rna_userdef_update");
 
 	prop= RNA_def_property(srna, "use_textured_fonts", PROP_BOOLEAN, PROP_NONE);
diff --git a/source/blender/python/SConscript b/source/blender/python/SConscript
index 9d7928c4432..5cc3f3bedc4 100644
--- a/source/blender/python/SConscript
+++ b/source/blender/python/SConscript
@@ -17,6 +17,9 @@ defs = []
 if is_debug:
     defs.append('_DEBUG')
 
+if env['WITH_BF_INTERNATIONAL']:
+    defs.append('INTERNATIONAL')
+
 sources = env.Glob('generic/*.c')
 env.BlenderLib( libname = 'bf_python_ext', sources = Split(sources), includes = Split(incs), defines = defs, libtype = ['core','player'], priority = [363,165]) # ketsji is 360
 
diff --git a/source/blender/python/generic/CMakeLists.txt b/source/blender/python/generic/CMakeLists.txt
index 8dfbf476995..0a49036c15d 100644
--- a/source/blender/python/generic/CMakeLists.txt
+++ b/source/blender/python/generic/CMakeLists.txt
@@ -48,5 +48,8 @@ set(SRC
 	py_capi_utils.h
 )
 
+if(WITH_INTERNATIONAL)
+        add_definitions(-DINTERNATIONAL)
+endif()
 
 blender_add_lib(bf_python_ext "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/source/blender/python/generic/blf_py_api.c b/source/blender/python/generic/blf_py_api.c
index 3cf0b0f1f27..abf5ee7bada 100644
--- a/source/blender/python/generic/blf_py_api.c
+++ b/source/blender/python/generic/blf_py_api.c
@@ -31,9 +31,13 @@
 #include "blf_py_api.h"
 
 #include "../../blenfont/BLF_api.h"
+#include "../../blenfont/BLF_translation.h"
 
 #include "BLI_utildefines.h"
 
+#ifdef INTERNATIONAL
+#include "DNA_userdef_types.h"	/* is it bad level? */
+#endif
 
 
 PyDoc_STRVAR(py_blf_position_doc,
@@ -367,6 +371,34 @@ static PyObject *py_blf_load(PyObject *UNUSED(self), PyObject *args)
 	return PyLong_FromLong(BLF_load(filename));
 }
 
+#ifdef INTERNATIONAL
+PyDoc_STRVAR(py_blf_gettext_doc,
+".. function:: gettext(msgid)\n"
+"\n"
+"   Get a msg in local language.\n"
+"\n"
+"   :arg msgid: the source string.\n"
+"   :type msgid: string\n"
+"   :return: the localized string.\n"
+"   :rtype: string\n"
+);
+static PyObject *py_blf_gettext(PyObject *UNUSED(self), PyObject *value)
+{
+	if ((U.transopts & USER_DOTRANSLATE) && (U.transopts & USER_TR_IFACE)) {
+		const char *msgid= _PyUnicode_AsString(value);
+		if(msgid == NULL) {
+			PyErr_SetString(PyExc_TypeError, "blf.gettext expects a single string argument");
+			return NULL;
+		}
+
+		return PyUnicode_FromString(BLF_gettext(msgid));
+	}
+	else {
+		return Py_INCREF(value), value;
+	}
+}
+#endif /* INTERNATIONAL */
+
 /*----------------------------MODULE INIT-------------------------*/
 static PyMethodDef BLF_methods[] = {
 	{"aspect", (PyCFunction) py_blf_aspect, METH_VARARGS, py_blf_aspect_doc},
@@ -382,6 +414,9 @@ static PyMethodDef BLF_methods[] = {
 	{"shadow_offset", (PyCFunction) py_blf_shadow_offset, METH_VARARGS, py_blf_shadow_offset_doc},
 	{"size", (PyCFunction) py_blf_size, METH_VARARGS, py_blf_size_doc},
 	{"load", (PyCFunction) py_blf_load, METH_VARARGS, py_blf_load_doc},
+#ifdef INTERNATIONAL
+	{"gettext", (PyCFunction) py_blf_gettext, METH_O, py_blf_gettext_doc},
+#endif
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/windowmanager/SConscript b/source/blender/windowmanager/SConscript
index 80c526f8649..c60752b85f8 100644
--- a/source/blender/windowmanager/SConscript
+++ b/source/blender/windowmanager/SConscript
@@ -39,4 +39,7 @@ if env['OURPLATFORM'] != 'darwin' or env['WITH_GHOST_COCOA']:
 if env['BF_BUILDINFO']:
     defs.append('WITH_BUILDINFO')
 
+if env['WITH_BF_INTERNATIONAL']:
+    defs.append('INTERNATIONAL')
+
 env.BlenderLib ( 'bf_windowmanager', sources, Split(incs), defines=defs, libtype=['core'], priority=[5] )
diff --git a/source/blender/windowmanager/intern/wm_files.c b/source/blender/windowmanager/intern/wm_files.c
index 6b3a574b6b6..f862af6173a 100644
--- a/source/blender/windowmanager/intern/wm_files.c
+++ b/source/blender/windowmanager/intern/wm_files.c
@@ -59,6 +59,8 @@
 #include "BLI_utildefines.h"
 #include "BLI_callbacks.h"
 
+#include "BLF_translation.h"
+
 #include "DNA_anim_types.h"
 #include "DNA_ipo_types.h" // XXX old animation system
 #include "DNA_object_types.h"
@@ -429,16 +431,17 @@ void WM_read_file(bContext *C, const char *filepath, ReportList *reports)
 	else if(retval == BKE_READ_EXOTIC_OK_OTHER)
 		BKE_write_undo(C, "Import file");
 	else if(retval == BKE_READ_EXOTIC_FAIL_OPEN) {
-		BKE_reportf(reports, RPT_ERROR, "Can't read file: \"%s\", %s.", filepath, errno ? strerror(errno) : "Unable to open the file");
+		BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("Can't read file: \"%s\", %s.")), filepath,
+				errno ? strerror(errno) : UI_translate_do_iface(N_("Unable to open the file")));
 	}
 	else if(retval == BKE_READ_EXOTIC_FAIL_FORMAT) {
-		BKE_reportf(reports, RPT_ERROR, "File format is not supported in file: \"%s\".", filepath);
+		BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("File format is not supported in file: \"%s\".")), filepath);
 	}
 	else if(retval == BKE_READ_EXOTIC_FAIL_PATH) {
-		BKE_reportf(reports, RPT_ERROR, "File path invalid: \"%s\".", filepath);
+		BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("File path invalid: \"%s\".")), filepath);
 	}
 	else {
-		BKE_reportf(reports, RPT_ERROR, "Unknown error loading: \"%s\".", filepath);
+		BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("Unknown error loading: \"%s\".")), filepath);
 		BLI_assert(!"invalid 'retval'");
 	}
 
diff --git a/source/blender/windowmanager/intern/wm_init_exit.c b/source/blender/windowmanager/intern/wm_init_exit.c
index 837b7eb1f2f..1819fbe00c9 100644
--- a/source/blender/windowmanager/intern/wm_init_exit.c
+++ b/source/blender/windowmanager/intern/wm_init_exit.c
@@ -99,6 +99,7 @@
 
 #include "UI_interface.h"
 #include "BLF_api.h"
+#include "BLF_translation.h"
 
 #include "GPU_buffers.h"
 #include "GPU_extensions.h"
@@ -143,6 +144,8 @@ void WM_init(bContext *C, int argc, const char **argv)
 	/* get the default database, plus a wm */
 	WM_read_homefile(C, NULL, G.factory_startup);
 
+	BLF_lang_set(NULL);
+
 	/* note: there is a bug where python needs initializing before loading the
 	 * startup.blend because it may contain PyDrivers. It also needs to be after
 	 * initializing space types and other internal data.
@@ -379,7 +382,7 @@ void WM_exit_ext(bContext *C, const short do_python)
 	BIF_freeTemplates(C);
 	
 	free_ttfont(); /* bke_font.h */
-	
+
 	free_openrecent();
 	
 	BKE_freecubetable();
@@ -399,6 +402,7 @@ void WM_exit_ext(bContext *C, const short do_python)
 	free_posebuf();
 
 	BLF_exit();
+	BLF_free_unifont();
 	
 	ANIM_keyingset_infos_exit();
 	
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 5e4505abaa5..320dc2ecdda 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -49,7 +49,7 @@
 #include "DNA_userdef_types.h"
 #include "DNA_windowmanager_types.h"
 
-#include "BLF_api.h"
+#include "BLF_translation.h"
 
 #include "PIL_time.h"
 
@@ -78,6 +78,7 @@
 
 #include "BIF_gl.h"
 #include "BIF_glutil.h" /* for paint cursor */
+#include "BLF_api.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
@@ -150,12 +151,11 @@ void WM_operatortype_append(void (*opfunc)(wmOperatorType*))
 	opfunc(ot);
 
 	if(ot->name==NULL) {
-		static char dummy_name[] = "Dummy Name";
 		fprintf(stderr, "ERROR: Operator %s has no name property!\n", ot->idname);
-		ot->name= dummy_name;
+		ot->name= UI_translate_do_iface(N_("Dummy Name"));
 	}
 
-	RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:"(undocumented operator)"); // XXX All ops should have a description but for now allow them not to.
+	RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:UI_translate_do_iface(N_("(undocumented operator)"))); // XXX All ops should have a description but for now allow them not to.
 	RNA_def_struct_identifier(ot->srna, ot->idname);
 
 	BLI_ghash_insert(global_ops_hash, (void *)ot->idname, ot);
@@ -168,7 +168,7 @@ void WM_operatortype_append_ptr(void (*opfunc)(wmOperatorType*, void*), void *us
 	ot= MEM_callocN(sizeof(wmOperatorType), "operatortype");
 	ot->srna= RNA_def_struct(&BLENDER_RNA, "", "OperatorProperties");
 	opfunc(ot, userdata);
-	RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:"(undocumented operator)");
+	RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:UI_translate_do_iface(N_("(undocumented operator)")));
 	RNA_def_struct_identifier(ot->srna, ot->idname);
 
 	BLI_ghash_insert(global_ops_hash, (void *)ot->idname, ot);
@@ -362,7 +362,7 @@ wmOperatorType *WM_operatortype_append_macro(const char *idname, const char *nam
 	ot->poll= NULL;
 
 	if(!ot->description)
-		ot->description= "(undocumented operator)";
+		ot->description= UI_translate_do_iface(N_("(undocumented operator)"));
 	
 	RNA_def_struct_ui_text(ot->srna, ot->name, ot->description); // XXX All ops should have a description but for now allow them not to.
 	RNA_def_struct_identifier(ot->srna, ot->idname);
@@ -387,7 +387,7 @@ void WM_operatortype_append_macro_ptr(void (*opfunc)(wmOperatorType*, void*), vo
 	ot->poll= NULL;
 
 	if(!ot->description)
-		ot->description= "(undocumented operator)";
+		ot->description= UI_translate_do_iface(N_("(undocumented operator)"));
 
 	opfunc(ot, userdata);
 
@@ -784,7 +784,7 @@ int WM_operator_confirm_message(bContext *C, wmOperator *op, const char *message
 	else
 		properties= NULL;
 
-	pup= uiPupMenuBegin(C, "OK?", ICON_QUESTION);
+	pup= uiPupMenuBegin(C, UI_translate_do_iface(N_("OK?")), ICON_QUESTION);
 	layout= uiPupMenuLayout(pup);
 	uiItemFullO(layout, op->type->idname, message, ICON_NONE, properties, WM_OP_EXEC_REGION_WIN, 0);
 	uiPupMenuEnd(C, pup);
@@ -865,10 +865,10 @@ void WM_operator_properties_filesel(wmOperatorType *ot, int filter, short type,
 
 void WM_operator_properties_select_all(wmOperatorType *ot) {
 	static EnumPropertyItem select_all_actions[] = {
-			{SEL_TOGGLE, "TOGGLE", 0, "Toggle", "Toggle selection for all elements"},
-			{SEL_SELECT, "SELECT", 0, "Select", "Select all elements"},
-			{SEL_DESELECT, "DESELECT", 0, "Deselect", "Deselect all elements"},
-			{SEL_INVERT, "INVERT", 0, "Invert", "Invert selection of all elements"},
+			{SEL_TOGGLE, "TOGGLE", 0, N_("Toggle"), "Toggle selection for all elements"},
+			{SEL_SELECT, "SELECT", 0, N_("Select"), "Select all elements"},
+			{SEL_DESELECT, "DESELECT", 0, N_("Deselect"), "Deselect all elements"},
+			{SEL_INVERT, "INVERT", 0, N_("Invert"), "Invert selection of all elements"},
 			{0, NULL, 0, NULL, NULL}
 	};
 
@@ -877,25 +877,25 @@ void WM_operator_properties_select_all(wmOperatorType *ot) {
 
 void WM_operator_properties_gesture_border(wmOperatorType *ot, int extend)
 {
-	RNA_def_int(ot->srna, "gesture_mode", 0, INT_MIN, INT_MAX, "Gesture Mode", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "xmin", 0, INT_MIN, INT_MAX, "X Min", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "xmax", 0, INT_MIN, INT_MAX, "X Max", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "ymin", 0, INT_MIN, INT_MAX, "Y Min", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "ymax", 0, INT_MIN, INT_MAX, "Y Max", "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "gesture_mode", 0, INT_MIN, INT_MAX, N_("Gesture Mode"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "xmin", 0, INT_MIN, INT_MAX, N_("X Min"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "xmax", 0, INT_MIN, INT_MAX, N_("X Max"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "ymin", 0, INT_MIN, INT_MAX, N_("Y Min"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "ymax", 0, INT_MIN, INT_MAX, N_("Y Max"), "", INT_MIN, INT_MAX);
 
 	if(extend)
-		RNA_def_boolean(ot->srna, "extend", 1, "Extend", "Extend selection instead of deselecting everything first");
+		RNA_def_boolean(ot->srna, "extend", 1, _("Extend"), _("Extend selection instead of deselecting everything first"));
 }
 
 void WM_operator_properties_gesture_straightline(wmOperatorType *ot, int cursor)
 {
-	RNA_def_int(ot->srna, "xstart", 0, INT_MIN, INT_MAX, "X Start", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "xend", 0, INT_MIN, INT_MAX, "X End", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "ystart", 0, INT_MIN, INT_MAX, "Y Start", "", INT_MIN, INT_MAX);
-	RNA_def_int(ot->srna, "yend", 0, INT_MIN, INT_MAX, "Y End", "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "xstart", 0, INT_MIN, INT_MAX, N_("X Start"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "xend", 0, INT_MIN, INT_MAX, N_("X End"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "ystart", 0, INT_MIN, INT_MAX, N_("Y Start"), "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "yend", 0, INT_MIN, INT_MAX, N_("Y End"), "", INT_MIN, INT_MAX);
 	
 	if(cursor)
-		RNA_def_int(ot->srna, "cursor", cursor, 0, INT_MAX, "Cursor", "Mouse cursor style to use during the modal operator", 0, INT_MAX);
+		RNA_def_int(ot->srna, "cursor", cursor, 0, INT_MAX, N_("Cursor"), N_("Mouse cursor style to use during the modal operator"), 0, INT_MAX);
 }
 
 
@@ -924,7 +924,7 @@ static uiBlock *wm_block_create_redo(bContext *C, ARegion *ar, void *arg_op)
 	wmOperator *op= arg_op;
 	uiBlock *block;
 	uiLayout *layout;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	int width= 300;
 	
 
@@ -1002,7 +1002,7 @@ static uiBlock *wm_block_dialog_create(bContext *C, ARegion *ar, void *userData)
 	wmOperator *op= data->op;
 	uiBlock *block;
 	uiLayout *layout;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 
 	block = uiBeginBlock(C, ar, "operator dialog", UI_EMBOSS);
 	uiBlockClearFlag(block, UI_BLOCK_LOOP);
@@ -1026,7 +1026,7 @@ static uiBlock *wm_block_dialog_create(bContext *C, ARegion *ar, void *userData)
 		col= uiLayoutColumn(layout, FALSE);
 		col_block= uiLayoutGetBlock(col);
 		/* Create OK button, the callback of which will execute op */
-		btn= uiDefBut(col_block, BUT, 0, "OK", 0, -30, 0, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
+		btn= uiDefBut(col_block, BUT, 0, UI_translate_do_iface(N_("OK")), 0, -30, 0, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
 		uiButSetFunc(btn, dialog_exec_cb, data, col_block);
 	}
 
@@ -1043,7 +1043,7 @@ static uiBlock *wm_operator_ui_create(bContext *C, ARegion *ar, void *userData)
 	wmOperator *op= data->op;
 	uiBlock *block;
 	uiLayout *layout;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 
 	block= uiBeginBlock(C, ar, "opui_popup", UI_EMBOSS);
 	uiBlockClearFlag(block, UI_BLOCK_LOOP);
@@ -1213,7 +1213,7 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar
 	uiBlock *block;
 	uiBut *but;
 	uiLayout *layout, *split, *col;
-	uiStyle *style= U.uistyles.first;
+	uiStyle *style= UI_GetStyle();
 	struct RecentFile *recent;
 	int i;
 	MenuType *mt= WM_menutype_find("USERPREF_MT_splash", TRUE);
@@ -1272,19 +1272,19 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar
 	split = uiLayoutSplit(layout, 0, 0);
 	col = uiLayoutColumn(split, 0);
 	uiItemL(col, "Links", ICON_NONE);
-	uiItemStringO(col, "Donations", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/blenderorg/blender-foundation/donation-payment");
-	uiItemStringO(col, "Credits", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/credits");
-	uiItemStringO(col, "Release Log", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/release-logs/blender-259");
-	uiItemStringO(col, "Manual", ICON_URL, "WM_OT_url_open", "url", "http://wiki.blender.org/index.php/Doc:2.5/Manual");
-	uiItemStringO(col, "Blender Website", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org");
-	uiItemStringO(col, "User Community", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/community/user-community");
+	uiItemStringO(col, UI_translate_do_iface(N_("Donations")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/blenderorg/blender-foundation/donation-payment");
+	uiItemStringO(col, UI_translate_do_iface(N_("Credits")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/credits");
+	uiItemStringO(col, UI_translate_do_iface(N_("Release Log")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/release-logs/blender-259");
+	uiItemStringO(col, UI_translate_do_iface(N_("Manual")), ICON_URL, "WM_OT_url_open", "url", "http://wiki.blender.org/index.php/Doc:2.5/Manual");
+	uiItemStringO(col, UI_translate_do_iface(N_("Blender Website")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org");
+	uiItemStringO(col, UI_translate_do_iface(N_("User Community")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/community/user-community");
 	if(strcmp(STRINGIFY(BLENDER_VERSION_CYCLE), "release")==0) {
 		BLI_snprintf(url, sizeof(url), "http://www.blender.org/documentation/blender_python_api_%d_%d" STRINGIFY(BLENDER_VERSION_CHAR) "_release", BLENDER_VERSION/100, BLENDER_VERSION%100);
 	}
 	else {
 		BLI_snprintf(url, sizeof(url), "http://www.blender.org/documentation/blender_python_api_%d_%d_%d", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION);
 	}
-	uiItemStringO(col, "Python API Reference", ICON_URL, "WM_OT_url_open", "url", url);
+	uiItemStringO(col, UI_translate_do_iface(N_("Python API Reference")), ICON_URL, "WM_OT_url_open", "url", url);
 	uiItemL(col, "", ICON_NONE);
 
 	col = uiLayoutColumn(split, 0);
@@ -1294,7 +1294,7 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar
 		uiItemS(col);
 	}
 
-	uiItemL(col, "Recent", ICON_NONE);
+	uiItemL(col, UI_translate_do_iface(N_("Recent")), ICON_NONE);
 	for(recent = G.recent_files.first, i=0; (i<5) && (recent); recent = recent->next, i++) {
 		uiItemStringO(col, BLI_path_basename(recent->filepath), ICON_FILE_BLEND, "WM_OT_open_mainfile", "filepath", recent->filepath);
 	}
@@ -3304,13 +3304,13 @@ static void redraw_timer_window_swap(bContext *C)
 }
 
 static EnumPropertyItem redraw_timer_type_items[] = {
-	{0, "DRAW", 0, "Draw Region", "Draw Region"},
-	{1, "DRAW_SWAP", 0, "Draw Region + Swap", "Draw Region and Swap"},
-	{2, "DRAW_WIN", 0, "Draw Window", "Draw Window"},
-	{3, "DRAW_WIN_SWAP", 0, "Draw Window + Swap", "Draw Window and Swap"},
-	{4, "ANIM_STEP", 0, "Anim Step", "Animation Steps"},
-	{5, "ANIM_PLAY", 0, "Anim Play", "Animation Playback"},
-	{6, "UNDO", 0, "Undo/Redo", "Undo/Redo"},
+	{0, "DRAW", 0, N_("Draw Region"), N_("Draw Region")},
+	{1, "DRAW_SWAP", 0, N_("Draw Region + Swap"), N_("Draw Region and Swap")},
+	{2, "DRAW_WIN", 0, N_("Draw Window"), N_("Draw Window")},
+	{3, "DRAW_WIN_SWAP", 0, N_("Draw Window + Swap"), N_("Draw Window and Swap")},
+	{4, "ANIM_STEP", 0, N_("Anim Step"), N_("Animation Steps")},
+	{5, "ANIM_PLAY", 0, N_("Anim Play"), N_("Animation Playback")},
+	{6, "UNDO", 0, N_("Undo/Redo"), N_("Undo/Redo")},
 	{0, NULL, 0, NULL, NULL}};
 
 static int redraw_timer_exec(bContext *C, wmOperator *op)
@@ -3543,14 +3543,14 @@ void wm_operatortype_init(void)
 static void gesture_circle_modal_keymap(wmKeyConfig *keyconf)
 {
 	static EnumPropertyItem modal_items[] = {
-	{GESTURE_MODAL_CANCEL,	"CANCEL", 0, "Cancel", ""},
-	{GESTURE_MODAL_CONFIRM,	"CONFIRM", 0, "Confirm", ""},
-	{GESTURE_MODAL_CIRCLE_ADD, "ADD", 0, "Add", ""},
-	{GESTURE_MODAL_CIRCLE_SUB, "SUBTRACT", 0, "Subtract", ""},
+	{GESTURE_MODAL_CANCEL,	"CANCEL", 0, N_("Cancel"), ""},
+	{GESTURE_MODAL_CONFIRM,	"CONFIRM", 0, N_("Confirm"), ""},
+	{GESTURE_MODAL_CIRCLE_ADD, "ADD", 0, N_("Add"), ""},
+	{GESTURE_MODAL_CIRCLE_SUB, "SUBTRACT", 0, N_("Subtract"), ""},
 
-	{GESTURE_MODAL_SELECT,	"SELECT", 0, "Select", ""},
-	{GESTURE_MODAL_DESELECT,"DESELECT", 0, "DeSelect", ""},
-	{GESTURE_MODAL_NOP,"NOP", 0, "No Operation", ""},
+	{GESTURE_MODAL_SELECT,	"SELECT", 0, N_("Select"), ""},
+	{GESTURE_MODAL_DESELECT,"DESELECT", 0, N_("DeSelect"), ""},
+	{GESTURE_MODAL_NOP,"NOP", 0, N_("No Operation"), ""},
 
 
 	{0, NULL, 0, NULL, NULL}};
@@ -3596,9 +3596,9 @@ static void gesture_circle_modal_keymap(wmKeyConfig *keyconf)
 static void gesture_straightline_modal_keymap(wmKeyConfig *keyconf)
 {
 	static EnumPropertyItem modal_items[] = {
-		{GESTURE_MODAL_CANCEL,	"CANCEL", 0, "Cancel", ""},
-		{GESTURE_MODAL_SELECT,	"SELECT", 0, "Select", ""},
-		{GESTURE_MODAL_BEGIN,	"BEGIN", 0, "Begin", ""},
+		{GESTURE_MODAL_CANCEL,	"CANCEL", 0, N_("Cancel"), ""},
+		{GESTURE_MODAL_SELECT,	"SELECT", 0, N_("Select"), ""},
+		{GESTURE_MODAL_BEGIN,	"BEGIN", 0, N_("Begin"), ""},
 		{0, NULL, 0, NULL, NULL}};
 	
 	wmKeyMap *keymap= WM_modalkeymap_get(keyconf, "Gesture Straight Line");
@@ -3624,10 +3624,10 @@ static void gesture_straightline_modal_keymap(wmKeyConfig *keyconf)
 static void gesture_border_modal_keymap(wmKeyConfig *keyconf)
 {
 	static EnumPropertyItem modal_items[] = {
-	{GESTURE_MODAL_CANCEL,	"CANCEL", 0, "Cancel", ""},
-	{GESTURE_MODAL_SELECT,	"SELECT", 0, "Select", ""},
-	{GESTURE_MODAL_DESELECT,"DESELECT", 0, "DeSelect", ""},
-	{GESTURE_MODAL_BEGIN,	"BEGIN", 0, "Begin", ""},
+	{GESTURE_MODAL_CANCEL,	"CANCEL", 0, N_("Cancel"), ""},
+	{GESTURE_MODAL_SELECT,	"SELECT", 0, N_("Select"), ""},
+	{GESTURE_MODAL_DESELECT,"DESELECT", 0, N_("DeSelect"), ""},
+	{GESTURE_MODAL_BEGIN,	"BEGIN", 0, N_("Begin"), ""},
 	{0, NULL, 0, NULL, NULL}};
 
 	wmKeyMap *keymap= WM_modalkeymap_get(keyconf, "Gesture Border");
@@ -3679,10 +3679,10 @@ static void gesture_border_modal_keymap(wmKeyConfig *keyconf)
 static void gesture_zoom_border_modal_keymap(wmKeyConfig *keyconf)
 {
 	static EnumPropertyItem modal_items[] = {
-	{GESTURE_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""},
-	{GESTURE_MODAL_IN,	"IN", 0, "In", ""},
-	{GESTURE_MODAL_OUT, "OUT", 0, "Out", ""},
-	{GESTURE_MODAL_BEGIN, "BEGIN", 0, "Begin", ""},
+	{GESTURE_MODAL_CANCEL, "CANCEL", 0, N_("Cancel"), ""},
+	{GESTURE_MODAL_IN,	"IN", 0, N_("In"), ""},
+	{GESTURE_MODAL_OUT, "OUT", 0, N_("Out"), ""},
+	{GESTURE_MODAL_BEGIN, "BEGIN", 0, N_("Begin"), ""},
 	{0, NULL, 0, NULL, NULL}};
 
 	wmKeyMap *keymap= WM_modalkeymap_get(keyconf, "Gesture Zoom Border");
diff --git a/source/blender/windowmanager/intern/wm_window.c b/source/blender/windowmanager/intern/wm_window.c
index 7d6010786d2..d9ca275c819 100644
--- a/source/blender/windowmanager/intern/wm_window.c
+++ b/source/blender/windowmanager/intern/wm_window.c
@@ -48,6 +48,8 @@
 #include "BLI_blenlib.h"
 #include "BLI_utildefines.h"
 
+#include "BLF_translation.h"
+
 #include "BKE_blender.h"
 #include "BKE_context.h"
 #include "BKE_library.h"
@@ -73,6 +75,8 @@
 #include "GPU_draw.h"
 #include "GPU_extensions.h"
 
+#include "UI_interface.h"
+
 /* the global to talk to ghost */
 static GHOST_SystemHandle g_system= NULL;
 
@@ -504,11 +508,11 @@ void WM_window_open_temp(bContext *C, rcti *position, int type)
 	ED_screen_set(C, win->screen);
 	
 	if(sa->spacetype==SPACE_IMAGE)
-		GHOST_SetTitle(win->ghostwin, "Blender Render");
+		GHOST_SetTitle(win->ghostwin, UI_translate_do_iface(N_("Blender Render")));
 	else if(ELEM(sa->spacetype, SPACE_OUTLINER, SPACE_USERPREF))
-		GHOST_SetTitle(win->ghostwin, "Blender User Preferences");
+		GHOST_SetTitle(win->ghostwin, UI_translate_do_iface(N_("Blender User Preferences")));
 	else if(sa->spacetype==SPACE_FILE)
-		GHOST_SetTitle(win->ghostwin, "Blender File View");
+		GHOST_SetTitle(win->ghostwin, UI_translate_do_iface(N_("Blender File View")));
 	else
 		GHOST_SetTitle(win->ghostwin, "Blender");
 }
diff --git a/source/creator/CMakeLists.txt b/source/creator/CMakeLists.txt
index 666be16e73e..0b5d9f7c15c 100644
--- a/source/creator/CMakeLists.txt
+++ b/source/creator/CMakeLists.txt
@@ -356,7 +356,9 @@ if(UNIX AND NOT APPLE)
 		)
 
 		install(
-			DIRECTORY ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
+			DIRECTORY
+				${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
+				${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts
 			DESTINATION ${TARGETDIR_VER}/datafiles
 			PATTERN ".svn" EXCLUDE
 		)
@@ -430,7 +432,9 @@ elseif(WIN32)
 			DESTINATION ${TARGETDIR_VER}
 		)
 		install(
-			DIRECTORY ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
+			DIRECTORY
+				${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
+				${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts
 			DESTINATION ${TARGETDIR_VER}/datafiles
 			PATTERN ".svn" EXCLUDE
 		)
@@ -449,8 +453,10 @@ elseif(WIN32)
 	endif()
 
 	install( # same as linux!, deduplicate
-		DIRECTORY ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
-		DESTINATION ${TARGETDIR_VER}/datafiles/locale
+		DIRECTORY
+			${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
+			${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts
+		DESTINATION ${TARGETDIR_VER}/datafiles
 		PATTERN ".svn" EXCLUDE
 	)
 
@@ -662,9 +668,12 @@ elseif(APPLE)
 			DESTINATION ${TARGETDIR_VER}/datafiles
 		)
 
-		install_dir(
-			${CMAKE_SOURCE_DIR}/release/bin/.blender/locale/
-			\${TARGETDIR_VER}/datafiles/locale
+		install(
+			DIRECTORY
+				${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts
+				${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
+			DESTINATION ${TARGETDIR_VER}/datafiles
+			PATTERN ".svn" EXCLUDE
 		)
 	endif()
 
diff --git a/source/gameengine/GamePlayer/ghost/CMakeLists.txt b/source/gameengine/GamePlayer/ghost/CMakeLists.txt
index 944ec9abd67..b452bb97cde 100644
--- a/source/gameengine/GamePlayer/ghost/CMakeLists.txt
+++ b/source/gameengine/GamePlayer/ghost/CMakeLists.txt
@@ -78,4 +78,8 @@ if(WITH_CODEC_FFMPEG)
 	add_definitions(-DWITH_FFMPEG)
 endif()
 
+if(WITH_INTERNATIONAL)
+	add_definitions(-DINTERNATIONAL)
+endif()
+
 blender_add_lib_nolist(ge_player_ghost "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
index d4ce19de83f..eee27ca0790 100644
--- a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
+++ b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
@@ -81,6 +81,7 @@ extern char btempdir[];		/* use this to store a valid temp directory */
 
 // For BLF
 #include "BLF_api.h"
+#include "BLF_translation.h"
 extern int datatoc_bfont_ttf_size;
 extern char datatoc_bfont_ttf[];
 
@@ -404,7 +405,7 @@ int main(int argc, char** argv)
 	// We don't use threads directly in the BGE, but we need to call this so things like
 	// freeing up GPU_Textures works correctly.
 	BLI_threadapi_init();
-	
+
 	RNA_init();
 
 	init_nodesystem();
@@ -420,6 +421,9 @@ int main(int argc, char** argv)
 	// Setup builtin font for BLF (mostly copied from creator.c, wm_init_exit.c and interface_style.c)
 	BLF_init(11, U.dpi);
 	BLF_lang_init();
+	BLF_lang_encoding("");
+	BLF_lang_set("");
+
 	BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size);
 
 	// Parse command line options
@@ -994,6 +998,7 @@ int main(int argc, char** argv)
 	// Cleanup
 	RNA_exit();
 	BLF_exit();
+	BLF_free_unifont();
 	IMB_exit();
 	free_nodesystem();
 
diff --git a/source/gameengine/GamePlayer/ghost/SConscript b/source/gameengine/GamePlayer/ghost/SConscript
index de063f5e297..57c1122c2cd 100644
--- a/source/gameengine/GamePlayer/ghost/SConscript
+++ b/source/gameengine/GamePlayer/ghost/SConscript
@@ -51,4 +51,7 @@ if env['WITH_BF_PYTHON']:
 if env['WITH_BF_FFMPEG']:
     defs.append('WITH_FFMPEG')
 
+if env['WITH_BF_INTERNATIONAL']:
+    defs.append('INTERNATIONAL')
+
 env.BlenderLib (libname='ge_player_ghost', sources=source_files, includes = incs, defines = defs, libtype=['player'],priority=[0], cxx_compileflags=env['BGE_CXXFLAGS'])