Ren'Py Changelog

What's new in Ren'Py 6.99.11.1749

Sep 6, 2016
  • New In-Game GUI:
  • Ren'Py ships with a new default GUI. This system, used in-game to customize the main menu, game menu, and in-game screens, replaces the old themes and screens.rpy system with a new system that's intended to be an improvement for every creator:
  • For new creators, the new GUI is intended to look attractive (if generic) out of the box. It is adaptable to a choice of sizes, and supports games with light and dark backgrounds.
  • Intermediate creators will be able to more easily customize the new GUI, without having to to work with screens and styles directly. It's now possible to completely re-theme the GUI by changing variables in the gui namespace, and editing template images.
  • Advanced creators will be able to replace the new gui entirely, either piece by piece or wholesale. The new gui infrastructure resets all styles to sensible defaults, making it easier to apply customization.
  • There is also a gui customization guide, consisting of over 5,000 words of documentation and code, and 40 images, that explains how to change the look of the GUI.
  • In addition, the new GUI adds support for a number of new features. These features are generally implemented in a way that custom GUIs can take advantage of.
  • Highlights include:
  • The GUI defaults to supporting 16:9 widescreen resolutions.
  • The new GUI is intended to support PCs and mobile devices in landscape mode. Where appropriate, it conforms to iOS and Android interface guidelines.
  • The new GUI includes native support for a history or readback screen.
  • The new GUI includes support for assigning names to file pages, allowing a certain amount of organization to be applied to files.
  • The NVL and choice screens are now given lists of objects as parameters, instead of tuples. (The objects also function as tuples, for compatibility with old code.)
  • The yesno_prompt screen has been renamed to confirm.
  • Ren'Py supports the use of a ctc screen to display the click-to-continue indicator.
  • Improved Platform Support link
  • There have been a number of fixes to Ren'Py's support for various platforms.
  • Windows HighDPI mode is detected properly when displaying the presplash.
  • Android The Android build system has undergone a rewrite, adding support for x86, while retaining and modernizing support for ARM devices. RAPT now included many dependencies, fixing Android build problems.
  • Ren'Py now supports immersive mode on Android's 4.4+. Immersive mode hides the system UI, including the navigation bar, allowing Ren'Py to take up the entire screen.
  • Chrome OS Ren'Py now support ChromeOS by running the Android APKs via the Android Runtime for Chrome tool.
  • Style Prefix Support:
  • Ren'Py now supports the use of a prefix_ substitution with style properties. Where previously, one was required to write:
  • style button:
  • insensitive_background "insensitive_button.png"
  • idle_background "idle_button.png"
  • hover_background "hover_button.png"
  • selected_idle_background "selected_idle_button.png"
  • selected_hover_background "selected_hover_button.png"
  • one can now write:
  • style button:
  • background "[prefix_]button.png"
  • This searches through prefixes in a manner similar to the way styles do. When looking for a selected_idle_background, Ren'Py will search for selected_idle_background.png, idle_background.png, and background.png
  • Style Properties:
  • Windows and buttons can take the padding and margin style properties. These properties can take a tuple that gives the margin and padding on all four sides.
  • The new base_bar style property sets the left and right (or top and bottom) bars to the same value. It can be to set the background of a slider or scrollbar the uses a thumb image.
  • The xfit and yfit style properties can be given to the fixed screen language statement and Fixed() displayable. When a fit property is true, the fixed shrinks in the given axis to fit all child displayables.
  • Buttons and Windows now fully respect the xmaximum and ymaximum style properties.
  • There is now a offset style property, which sets the xoffset and :propfref:`yoffset` properties to the first and second components of a tuple.
  • Translate and Style Statement Order Changes:
  • The config.defer_styles variable has been added to determine if style execution should be deferred, as described below. If config.defer_styles is true when style evaluation would have occurred, that style is put on a deferred list. The gui.init() function called by the new GUI sets this variable to true.
  • To facilitate translations customizing the fonts of the new GUI, the order of execution of translate python, style and translate style statements has been changed. When the game starts (after all statements have run), or when the language changes, the following steps occur.
  • The gui named store is cleaned to its state at the end if init. (This is the store that all variables defined with gui.`name` live in.)
  • All translate language python statements are run, where language is the current language.
  • All deferred style statements are run.
  • All translate language style statement are run, where language is the current language. (If not None.)
  • The callbacks in config.change_language_callbacks are called.
  • Ren'Py can be made to return to the old behavior (in which only translate language style, translate language python, and callbacks are executed) by setti
  • Local Labels:
  • Ren'Py now supports labels scoped to inside another label. It's possible to write:
  • label day1:
  • menu:
  • "Should I sleep in?"
  • "Yes":
  • jump .afternoon
  • "No":
  • jump .morning
  • label .morning:
  • "It's the morning."
  • label .afternoon:
  • "It's the afternoon."
  • In this code, the .morning and .afternoon labels can be jumped to directly from code that is immediately after the day1 label, or by jumping to day1.morning or day1.afternoon from other code.
  • Transforms:
  • Transforms now support xtile and ytile transform properties. These properties allow the underlying displayable to be tiled multiple times.
  • Transforms now support xpan and ypan transform properties. These properties take an angle (between 0 and 360 degrees, but angles outside that are clamped to that range). The angle is used to pan the image horizontally or vertically by that amount. This makes it possible to simulate a 360 degree panoramic image.
  • Translations:
  • When generating a new project, all of the strings in the new game are translated using translations taken from the launcher project.
  • A Vietnamese translation of the launcher and tutorial have been added to Ren'Py. Thanks to Thuong Nguyen Huu for contributing it.
  • A Indonesian translation of the launcher and default project has been added to Ren'Py. Thanks to Pratomo Asta Nugraha for contributing it.
  • Ren'Py can now automatically generate a piglatin translation for test purposes.
  • Other:
  • The new nvl_narrator character can be used to as the narrator while in NVL-mode.
  • The define statement can be used to define variables that are also Ren'Py keywords. For example, "define menu = nvl_menu" now works.
  • A Frame() can now be given a Borders() object, that encapsulates the borders of a Frame into a single object. Borders objects also have a padding field that can be passed into the new :properf:`padding` style property.
  • Buttons, textbuttons, imagebuttons, and hotspots now take selected and sensitive properties that directly control if the button is selected or sensitive.
  • Buttons, textbuttons, imagebuttons, and hotspots take keysym and alternate_keysym bindings, that make it possible to assign keys to the buttons. When the given key is pressed, the action or alternate action is run.
  • Ren'Py now supports extracting string translations from one project and applying them to another project. The translations can also be applied in reverse order, turning an English -> Russian interface translation into a Russian -> English translation.
  • Viewports and vpgrids now support an arrowkeys property, that makes the viewport scrollable using arrow keys and a controller d-pad.
  • Viewports and vpgrids now support horizontal scrolling via the mouse wheel, by setting their mousewheel parameter to "horizontal".
  • InputValues now take a returnable property, that causes their value to be returned when enter is pressed.
  • Ren'Py support a renpy.get_refresh_rate() function, which returns the referesh rate of the primary screen. This allows games using nearest neighbor mode to move at a whole-pixel rate - just like a Commodore 64 did.
  • Ren'Py can now automatically upload your game to itch.io, if build.itch_project is set.
  • The config.after_load_callbacks can be given callback functions to run once a load has been completed.
  • The config.tts_voice variable has been added, to allow for a platform-specific choice of text-to-speech voice to use.
  • config.quit_action now defaults to Quit(), which will display the quit prompt over the in-game interface.
  • The progress indicator now can be accessed using the F2 key, in addition to the shift-alt-P binding. The latter binding has been fixed to work reliably on PC platforms.

New in Ren'Py 6.99.6.739 (Sep 15, 2015)

  • HighDPI/Retina:
  • Support for HighDPI/Retina displays has been added to Ren'Py. This support is automatically used when running on iOS or Mac OS X systems that have a retina display.
  • On all platforms, Ren'Py now renders text at the display resolution, rather than the resolution the game was set to. The result is that text remains sharp even when upscaled significantly. Creators should be aware that due to variability in character size and kerning, this can cause changes in text layout and word wrap as the window is scaled.
  • To get the greatest benefit from these changes, the included copy of DejaVuSans has been updated to version 2.35, and the DejaVuSans-Bold font has been added. The bold font will automatically be used when a bold version of DejaVuSans.ttf is requested.
  • Gamepad:
  • Ren'Py now uses the SDL2 controller API to support gamepads. This API provides a standardized mapping of controller buttons to something similar to an Xbox controller.
  • Backups:
  • Ren'Py will now automatically back up .rpy files that are part of changed games. These backups will be placed in the same system-specific location that save files are placed.
  • Other Improvements:
  • A new achievement.sync() function and achievement.Sync action have been added to Ren'Py. These synchronize achivements between local storage and other backends, such as Steam.
  • A major bug in scanning archive files has been fixed. This bug often manifested as an archived images/ directory not being scanned some, but potentially not all, of the time. We strongly recommend upgrading from 6.99.5 if your game uses and archives the images/ directory.
  • If a file is not found in the game directory, Ren'Py will search the images/ directory for that file. This behavior is controlled by the config.search_path variable.
  • Screens now take the style_group property, which was previously only allowed on displayable statements.
  • Screen language statements now take arguments and properties properties, which allows statement to be passed a list of additional positional arguments and a dict of additional properties, respectively.
  • The new Color class allows conversion between color spaces and other color-theory operations.
  • Ren'Py now supports a game/python-packages directory, which can be used with pure-python packages installed via pip. See the new First and Third Party Python Modules and Packages documentation for more details.
  • Renios now supports compiling for 32-bit simulators (for the iPhone 4 and 5).
  • The Korean and Russian translations have been improved.

New in Ren'Py 6.99.5.602 (Jul 20, 2015)

  • This release improves startup time, improves iOS 8 support, and includes other improvements and fixes.

New in Ren'Py 6.99.4.467 (Jul 20, 2015)

  • This release adds new features. It also fixes a number of bugs and performance problems.

New in Ren'Py 6.99.3.404 (Apr 27, 2015)

  • Removes extraneous code that was causing problems.

New in Ren'Py 6.99.2.403 (Apr 27, 2015)

  • Adds new features, including the images directory and the AlphaMask displayable. It also fixes bugs.

New in Ren'Py 6.99.1.329 (Mar 30, 2015)

  • Fixes crashes that occurred in a number of important cases, including non-ASCII directory names on Windows systems, 16-bit display depths, and display rotation when targeting recent versions of Android.
  • It also fixes several non-crash bugs, adds three new functions, and updates the Spanish and Japanese translations.

New in Ren'Py 6.99.0 (Mar 26, 2015)

  • SDL2:
  • Ren'Py is now based on Pygame_SDL2, a reimplementation of the Pygame API based on the SDL2 library. One of the largest changes in Ren'Py's history, switching to SDL2 lays the groundwork for many improvements, in this and future releases.
  • iOS Support:
  • Ren'Py now supports the iOS platform. To develop for iOS, you will need a Macintosh computer, Xcode, and a paid membership in the iOS developer program. (An iPad or iPhone to test with is highly recommended.)
  • Ren'Py's iOS support includes the ability to create Xcode projects, and to update those projects with the latest version of a Ren'Py game. Xcode can be used to change project settings, and to create debug and release builds.
  • The iOS port supports iOS 7 and higher. Almost all of Ren'Py is supported, with the exception being that video playback is limited to fullscreen video in formats the iOS device supports.
  • For now, the default set of Ren'Py screens are not particularly compatible with iOS. You will need to customize your game to make it touch friendly and compliant with Apple's guidelines before submitting it to the iOS app store.
  • Please see the iOS documentation for more information and a copyright notice you must include as part of your app description on iOS.
  • Android Support:
  • Android support has been rewritten, and is now based in SDL2. This release brings Android support to parity with desktop platforms. Improvements include:
  • Support for rotating the screen to match the user's preferred orientation.
  • Improved in-app purchase support, with the ability to retrieve prices and create a single .apk that supports the Google and Amazon stores.
  • Android audio playback is now based on the same code that's used on the desktop and iOS platforms. This enables support for features like panning and fading volume. It also means the same sound files can be used on Android, iOS, and desktop platforms.
  • Keyboard input is now supported on Android.
  • Languages requiring bidirectional text (like Arabic and Hebrew) are supported on Android.
  • A number of issues with Android support have been fixed, including one that prevented Ren'Py from unzipping the android SDK automatically when the path to the Ren'Py install was too long.
  • Please see the Android documentation for more information and a copyright notice that should be included as part of your app description.
  • Steam:
  • Ren'Py now ships with Python bindings for the steam API. These bindings are built as part of the Ren'Py build process, which means they will be maintained alongside Ren'Py going forwards.
  • For an explanation of how to use the Steam API, please contact the Ren'Py developers directly. The bindings make available:
  • Initialization.
  • User statistics and achievements.
  • Retrieving other apps by the same developer that have been installed.
  • DLC support.
  • The in-game overlay, including the ability to launch a purchase flow.
  • Session tickets.
  • The steam bindings will be integrated with Ren'Py as appropriate. For now, this integration consists of binding the steam achievement system to the new Ren'Py achievement API.
  • Distribution Improvements:
  • The launcher now has the ability to add from clauses to call statements, automatically turning:
  • call dayplanner
  • into:
  • call dayplanner from __call_dayplanner
  • From clauses, which are really labels, help Ren'Py to find the return site to use when a game is changed. This should help fix problem with games that may change greatly between releases.
  • When asked to package a game that is more than about 2GB in size, Ren'Py will produce a ZIP64-format archive. These archives may be less compatible that smaller zip files.
  • Languages and Translations:
  • There is now a Russian translation of the tutorial game.
  • Ren'Py supports input methods (IMEs) on platforms where SDL2 makes that support available. (All platforms except for Linux.) Input methods make it possible to input complex non-ASCII text, such as Chinese, Japanese, and Korean.
  • Clipboard Voicing:
  • Ren'Py now supports clipboard voicing, which is accessed by shift+C.
  • Clipboard voicing is a form of self-voicing that works by copying the text to the clipboard, where a screenreader program is likely to read it using settings preferred by the player.
  • Custom Text Tags:
  • Ren'Py snow supports a new form of custom text tags.
  • Custom text tags are applied after the text has been tokenized into tags and text. This makes it easier to write a custom text tag that manipulates text or applies multiple existing text tags to text.
  • The previously-existing form of custom text tag has been renamed to style text tag, and is still supported.
  • Other Improvements:
  • A high-level achievement API has been added to Ren'Py.
  • Ren'Py now includes support for recognizing touch gestures on Android and iOS.
  • It is possible to hide the editing buttons in the launcher, so they can't be used to open an absurd number of editor windows.
  • The developer can choose if strings should be empty when generating translations.
  • Three new set manipulation actions AddToSet(), RemoveFromSet(), and ToggleSetMembership() manipulate sets and lists-as-sets. (Such as inventory lists.)
  • Drags (as in, drag-and-drop) now support the focus_mask style property.
  • The complexity of the style system has been reduced, decreasing memory usage and startup time.
  • The new renpy.suspend_rollback() suspends the recording of rollback checkpoints, while still allowing rollback to occur.
  • The RENPY_GL_CHECK_ERRORS controlls the logging of OpenGL/ANGLE function calls and errors.
  • A completion progress indicator can be toggled by typing shift-alt-P or swiping up-down-left-right-left-right.
  • As of this release, dictionary and set comprehensions are wrapped to support rollback.

New in Ren'Py 6.18.3.761 (Dec 13, 2014)

  • This release improves prediction, adds the new screen language "showif" statement, adds minor features, and fixes bugs.

New in Ren'Py 6.18.2.729 (Oct 13, 2014)

  • Adds many small new features, and fixes several minor bugs. It also adds the Traditional Chinese translation.

New in Ren'Py 6.18.1.670 (Sep 23, 2014)

  • Fixes a number of bugs in Ren'Py 6.18. It changes ATL behavior so that an ATL transform that is part of a screen will begin executing when the transform (rather than the screen) is first shown. It also adds a new placeholder image system, and a way to speak descriptive text as part of the self-voicing process.

New in Ren'Py 6.18.0 (Sep 15, 2014)

  • Screen Language Improvements:
  • This release includes a new implementation of screen language that has the potential to be much faster than the original implementation of screen language. Where the original screen language evaluated screens from scratch at the start of each interaction, this new implementation can incrementally reuse large portions of a screen between interactions. Please see the new Screen Language Optimization documentation for information on how to maximize screen language performance.
  • Of special note is that screens now perform better when defined with a parameter list. Screens that do not expect parameters should be defined with an empty parameter list.
  • To support improved optimization, when the screen language use statement calls a screen with a parameter list, only variables in that parameter list are updated. (This is a change in previously-undocumented behavior.)
  • Screens now support passing properties to a displayable from within an if statement, provided the if statement is the first thing inside the displayable. For example:
  • text "Eileen":
  • if eileen_mad:
  • color "#fcc"
  • else:
  • color "#cfc"
  • now works.
  • As there is now a larger benefit from predicting screens, screen prediction has been improved in several ways:
  • By default, Ren'Py will now use the arguments supplied to a screen in the show screen and call screen statements to predict the screen. This is potentially dangers, as it means that if either statement has side effects, those side effects will occur as part of screen prediction. To mitigate this problem, both statements now take a nopredict clause that prevents screen prediction.
  • Ren'Py will now attempt to predict images inside if clauses that would not be taken, and will ignore errors that occur during statement prediction.
  • A pair of functions, renpy.start_predict_screen() and renpy.stop_predict_screen() allows for manual prediction of time images that will be used by screens, including parameterized screens.
  • Ren'Py now supports profiling of screens, via the renpy.profile_screen() function.
  • Ren'Py has been changed to make a copy of the screens being displayed before a transition occurs. This makes it possible to use a transition to show screen updates. For example, one could increase the value displayed by a bar, and then use the dissolve transition to dissolve in the new segment of bar.
  • Image Prediction:
  • Ren'Py now has a supported mechanism for manually predicting images in cases where automatic image prediction fails. This mechanism consists of two functions: renpy.start_predict() starts prediction of images, while renpy.stop_predict() stops prediction.
  • Accessibility:
  • Ren'Py now includes support for self-voicing, a mode in which Ren'Py will read on-screen text to vision impaired players. To activate self-voicing, press the v key. For more information, please read the self-voicing documentation.
  • The new alt style property allows one to supply alternative text that allows Ren'Py to voice imagemap components and buttons with incomplete names.
  • The Ren'Py launcher now includes a large-text mode that can be accessed from the preferences page. This mode increases text size and contrast.
  • Android In-App Purchasing:
  • This version of Ren'Py includes a high-level interface that supports in-app purchasing on the Android platform. This interface currently support Google Play and the Amazon App Store.
  • Pixel Art:
  • Ren'Py supports nearest-neighbor filtering of images. This ensures that screen pixels correspond to a single texture pixel, which is the scaling mode preferred for use with pixel art. Nearest-neighbor mode is enabled with the new nearest transform property.
  • The new config.adjust_view_size() callback makes it possible to set the size of the Ren'Py viewport to something other than the size of the window (or screen, in fullscreen mode). For example, a game can use this callback to limit its viewport size to integer multiples of its native size.
  • Voice Improvements:
  • Voice volume is now adjustable on a per-character basis, using the voice_tag argument to Character() and the new VoiceVolume() value.
  • Using the new config.emphasize_audio_channels variable, Ren'Py can emphasize audio on some channels. This is doen by lowering the volume of non-emphasized channels when a emphasized channel is playing, and returning the volumes to normal when no emphasized chanels are playing. By setting this variable to [ 'voice' ], the voice channel can be emphasized over music and other sounds,
  • OS X Bug Workaround:
  • To workaround a bug in Mac OS X 10.9, Ren'Py will now always open on the the primary monitor of a Macintosh.
  • Other:
  • With some limitations, non-ASCII characters can now be used as character names. Since Python code does not allow non-ASCII identifiers, such character names must be defined by the define statement, and used outside Python code.
  • The auto property of imagebuttons and imagemaps now can take image names as well as image filenames.
  • The new renpy.image_exists() function returns true if an image has been defined.
  • Gallery navigation can now be customized by customizing the gallery_nav screen.
  • The new renpy.count_dialogue_blocks() and renpy.count_seen_dialogue_blocks() return the total number of dialogue blocks and the number of dialogue blocks that have been seen by the current user in any game. With some caveats, these can provide an indication of how much of the game the user has seen.
  • The config.autosave_on_choice variable determines if Ren'Py will autosave on choice, while the config.autosave_on_quit variable determines if Ren'Py will autosave when the game is about to end (by quit, return, or loading a save slot).
  • The new events transform property determines if events are passed to a transform's children. This is useful for ATL transforms, when some children should not receive events.
  • Save dumps (enabled by config.save_dump) are performed before the save occurs, making them far more useful for debugging pickling problems.
  • When show_ arguments are past to an NVLCharacter(), the show_ prefix is stripped and those arguments are passed to the nvl screen.
  • Translations:
  • This release add an Italian translation of the launcher and template game, contributed by Oshi-Shinobu.
  • This release adds a Portuguese translation of the template game, contributed by Mrstalker.
  • This release adds a Simplified Chinese translation of the launcher, contributed by Huanxuantian.

New in Ren'Py 6.17.7.521 (Jul 12, 2014)

  • Updates the Android SDK to a working version, adds a low-level in-app purchasing framework, and fixes an issue with movie playback on desktop platforms.

New in Ren'Py 6.17.6.512 (Jun 7, 2014)

  • Adds new German and Korean translations, and works around a bug that prevented the Ren'Py launcher from starting on certain macs.

New in Ren'Py 6.16.1.409 (Nov 11, 2013)

  • This release includes a number of bug fixes related to translation and running in non-ASCII directories, including a fix to the updater. It also includes documentation improvements.

New in Ren'Py 6.15.7.374 (Sep 3, 2013)

  • Fix a regression in ImageDissolve.

New in Ren'Py 6.13.12.1728 (May 8, 2012)

  • Fixes a related minimize and restore bug.
  • Improves compatibility with games that replace config.keymap.
  • Allows StylePreference and Language to work together.
  • Logs to the system temp directory if it can't writhe to the current directory.
  • Allows the screenshot filename to be configured by the creator.
  • Fixes keyboard adjustment of bars.
  • Updates the preferences screen when the window resizes.
  • Clears keyboard modifiers (like alt) when the window gains focus. This fixes a problem where the alt from an alt-tab would be remembered by Ren'Py, even after the key has been released.

New in Ren'Py 6.13.7.1646 (Oct 19, 2011)

  • Fixes a problem with substitutions in the launcher. Fixes a crash on font searching. On Android, merges multiple taps so as not to overwhelm the event queue.

New in Ren'Py 6.13.6.1642 (Oct 14, 2011)

  • Fixes a crash when loading automatically-created styles. Fixes a problem with quick saving not taking a screenshot. Fixes a problem with small solid textures not showing up, on the software renderer. Fixes a crash when playing back movies on Linux.
  • This release introduces two new actions, QuickSave and QuickLoad, which are used for quick save and qick load functionality. If your game uses the new quick menu, please update it with the new code found in template/game/screens.rpy.

New in Ren'Py 6.13.5.1638 (Oct 11, 2011)

  • Fixes slow text.

New in Ren'Py 6.13.4.1637 (Oct 10, 2011)

  • Jumps from called screens now work. This fixes the developer menu.
  • Hitting shift+G in-game brings the user to the renderer selection menu.
  • Include all source required to rebuild Ren'Py.
  • Fix the renpy-ppc packaging.

New in Ren'Py 6.13.0.1629 (Oct 4, 2011)

  • Released bugfix release 6.13.1.

New in Ren'Py 6.13.0 (Sep 30, 2011)

  • Text Rewrite:
  • Text display has been rewritten from scratch. In addition to supporting many new features, the new implementation of Text is much faster at text layout and display, and contains much cleaner code.
  • Some of the new features that are now supported by the text display system are:
  • Interpolation of variables enclosed in square brackets. It's now possible to write code like:
"You scored [score] out of a possible [max_score] points."
  • 


The new string interpolation takes place on all text that is displayed, rather than just say and menu statements. When used as part of a screen, interpolation has access to screen-local variables.
PEP 3101-style string formatting is supported, which means that this syntax can be used to display fields and items, as well as variables.
  • Kerning support was added, both as the kerning style property and the k text tag.
  • Support for ruby text (also known as furigana), via the rt and rb text tags, and the ruby_style style property.
  • The new space and vspace text tags make it easy to whitespace into the text.
  • The new cps text tag controls the speed of text display.
  • By default, Ren'Py uses the unicode linebreaking algorithm to find points at which a line can be broken. This algorithm should correctly break lines that contain a mix of western and eastern languages. Since that algorithm is incorrect on some Korean texts, Ren'Py also implements a korean-with-spaces variant, that only breaks runs of Korean text at whitespace. These algorithms can be selected by the language style property.
  • Ren'Py now uses the Knuth-Plass linebreaking algorithm to choose the points at which it actually splits lines. This algorithm attempts to minimize the unevenness of all lines except the last. Ren'Py also supports a nobreak mode, which allows one to create a Text larger than the screen without it being automatically wrapped. These can be selected using the layout style property.
  • The new newline_indent style property determines if Ren'Py adds indentation after a newline in text.
  • The new line_leading style property inserts space above a line of text. (Ruby text can be placed into this space.)
  • Text can be automatically translated before it is displayed. (This support will be improved in a future major release.)
  • DirectX Support:
  • On Windows systems that have the February 2010 DirectX update installed, Ren'Py will use DirectX via the ANGLE adaptation layer, in preference to OpenGL or software rendering. The ANGLE layer is used by popular web browsers such as Firefox and Google Chrome. This allows hardware rendering to be used on systems with built-in graphics, where drivers often support DirectX far better than OpenGL.
  • At startup, Ren'Py will test the graphics capabilities of the computer it is running on. If the software render is being used, or the game renders at an unacceptably slow speed, Ren'Py will display a warning message to the user. The warning message includes a link to a page on renpy.org that explains how to update the graphics drivers.
  • This version of Ren'Py will only use the software renderer if both DirectX and OpenGL are incapable of rendering Ren'Py games. Screen-scaling in the software renderer has been replaced by a simpler but slower version.
  • Other Changes:
  • Ren'Py now includes a style preference system. This system allows styles to be changed after the init phase has finished. These changes are saved with the persistent data. Among other things, style preferences allow a game to offer the user the option to change the font, size, and color of dialogue text.
  • Support has been added for screen-based image galleries and music rooms. This support consists of a classes that provides actions that make it easy to present the user with graphics and music. The creator is responsible for creating screens that use the supplied actions.
  • The default screens.rpy file, used when a new game is created, contains support for a "quick menu". This menu adds buttons to screens that allow the user to quick save, quick load, save, toggle skipping, toggle auto-forward mode, and access the preferences menu.
  • Ren'Py includes 5 new themes, and a number of new color schemes.
  • Several new actions have been added. The SelectedIf() action allows the creator to control if a button is displayed in the selected state. The SetMixer() action allows a mixer to be set to a specific value. The Rollback() and RollForward() actions allow the creator to bind rollback to buttons.
  • The behavior of the xfill and yfill style properties was accidentally changed in the 6.12 series. It has been returned to the historical behavior.
  • The Dissolve() and ImageDissolve() transitions now take a time_warp parameter.
  • The Frame() displayable now allows the user to specify the left, top, right, and bottom borders independently.
  • The caret style property allows the user to customize the caret of an input widget.
  • The renpy.displayable() function has been exposed to the user.
  • Timers can now take a list of actions, rather than just a single callable.
  • Three transforms were added to the default library: top, topleft, and topright.
  • Ren'Py can now load files (including images, music, and fonts) from an Android package.
  • User-defined statements can now take a block, which the statement is responsible for parsing.
  • Wrote documentation for:
  • Menus
  • Transforms
  • Creator-Defined Displayables
  • Several indexes were added to the documentation, and the style was updated.
  • Ren'Py now uses the libjpeg-turbo library, for faster jpeg loading. Ren'Py now uses libav 0.7.1, for improved compatibility with movie formats.
  • Removed support for the iLiad platform.
  • PowerPC support has been removed from the main Ren'Py distribution. It's available as a download from the Ren'Py web site.

New in Ren'Py 6.10.2 (Apr 7, 2010)

  • Ren'Py now caches the individual words of text that are rendered. This
  • can lead to a speedup in text display when there are many words of
  • text on the screen, and that text is re-displayed, as is the case
  • where the text text speed is not the maximum. This is especially
  • beneficial for eastasian languages, where every character is treated
  • as a word.
  • The new config.menu_clear_layers variable allows layers to be cleared
  • when entering the game menu. This makes it easier for a layer to have
  • overlay-like things on it when in the game, but not when in the game
  • menu.
  • The new renpy.cache_pin function pins images into memory, loading them
  • as soon as possible and keeping them loaded. The renpy.cache_unpin function
  • undoes this.
  • The new config.automatic_images_strip variable can strip out prefixes
  • when automatically defining images.
  • It's now possible to assign style properties to individual imagemap
  • buttons, by indexing style.imagemap_button. (So for example, one could
  • assign to style.imagemap_button["Start Game"].hover_sound .)
  • The new voice_replay function replays the voice played on the current
  • interaction. The new voice_can_replay function returns True if a voice
  • can be replayed.
  • The launcher now accepts a RENPY_DEFAULT_PROJECTS_DIRECTORY, which sets
  • the default for the projects directory, if it has not already been set
  • by the user. It also will report an error when creating a project fails,
  • rather than producing a traceback.
  • The launcher now links to the new Ren'Py Games List, at
  • http://games.renpy.org/.
  • Previously, it was impossible to pass an arguments list to a call
  • expression. Now, we allow the pass keyword to be used to distinguish
  • the two, using code like:
  • call expression foo pass (bar, baz)
  • Ren'Py will now not show the click-to-continue indicator when a
  • character is called with interact=False, unless that character is also
  • called with ctc_force=True.
  • Ren'Py now builds zip files in distributions 64k at a time.
  • Ren'Py will now ignore music files that do not exist. Previously, it
  • could loop trying to play them. (This would increase CPU usage, rather
  • than causing a crash.)
  • The following numbered bugs were fixed:
  • lp:501351 - Displaying a Frame() with tile=True crashes
  • lp:506322 - MoveTransition is not applied to overlay even when explicitly stated
  • In addition:
  • Fixed a bug that caused pixellate to crash.
  • Fixed a bug that caused the overlay to display twice in some cases.
  • Fix an infinite loop that could rarely occur when rolling back or saving.