CodeFlow readme

Version 1.2.3 (build 278)

CodeFlow 1.2 is focused at making live application development practical and easy. It comes with significant enhancements in project templates, including Swift 4 support and robust live-storyboard-update. It also brings an improved overall live developer experience, in fields like code editing, OS SDK bindings libraries, error detection, live code reload and Lua runtime errors handling.

This version includes the SDK Bindings Libraries for Xcode 9.2. SDK bindings Libraries for Xcode 8 and Xcode 7 are available as separate downloads.

Version 1.2.3 includes additional bug fixes.

For the detailed list of improvements in this version, please see the version history below.

What is CodeFlow?

CodeFlow is a Live Application Development Environment for iOS, tvOS and macOS.

Live App Development

Live Application Development is a more-natural more-interactive way of developing applications. Where old-style App development considers code-writing and app-running as two separate steps in the development cycle, Live Application Development gives you the freedom to code your application while it is running. Seeing the results of source code edits immediately in the real application, without having to re-build, re-load and re-run it, is incredibly fun and powerful, especially when creating the app's user interface or when fixing bugs.

As a Live App Development Environment, CodeFlow has been designed from the ground up to propagate source code changes in real time into the running application, so as to provide to developers a consistent real-time feedback of their work.

Actually, CodeFlow coordinates two main kinds of updates:

The first kind is live code update: when connected to a target application running on a device or in the simulator, CodeFlow keeps the Lua code in the target application in sync with the current project, updating it when necessary, without stopping stopping the application and preserving the app's current state.

The second kind of updates is live storyboard and resource update: when a monitored storyboard (or image, text, plist, sound, SceneKit assets …) is updated on the development computer, the new storyboard or resource version is loaded into the running target application, so the changes are immediately visible in the app and you can iterate quickly when you need it.

Live App Development is not limited to a single device: you can connect simultaneously multiple devices, with different screen sizes or different OS versions, to a same CodeFlow project, and benefit of live update on all of them!

Lua language

CodeFlow use the Lua programming language for Live Application development. Lua is a nice, fast, easy-to-learn and powerful language.

If you are not yet familiar with Lua, a good way to start is to read our Get Started with Lua tutorials.

Native APIs

With CodeFlow, you create native applications, that use native OS APIs, and run their native UI at native speed.

This is made possible by a key component of CodeFlow: the native bridge. In short, CodeFlow native bridge makes the OS SDK available to the Lua code in your app. Meaning that anything you can do in Objective-C or Swift, you can do it in Lua with CodeFlow. And there is more: the native bridge extends to your own custom code in the App Xcode project, so you can easily write hybrid applications, partly written using traditional Objective-C or Swift code, and partly written in Lua, with both parts capable of working closely together.

To learn more about the native bridge, read Get Started with Lua - CodeFlow Native Bridge.

Dedicated IDE

The CodeFlow IDE, running on macOS, has been expressly designed to support live application update while working hand-in-hand with Xcode. It includes a dedicated Lua code editor and a powerful always-available Lua debugger.

The Lua editor includes features like advanced syntax coloring, code indentation, syntax error detection, variables scoping, or automatic code completion (including native methods or property names from the OS SDK).

The Lua debugger supports breakpoints, step-by-step execution, and stop-on-error. It has a nice stack & variables inspector, that shows the contents of Lua local and global variables, capable of presenting useful information for both Lua and native values/objects. It supports multithreaded execution and shows all active Lua threads in the program at any given time. Finally, the Lua debugger includes a context-aware Lua command console, in which you can execute arbitrary code in the context of the selected Lua thread/stack-frame.

A codeFlow project can include Lua code files, as well as (non-code) resources (e.g. images). CodeFlow includes a QuickLook-base resource viewer, and delegates resource editing to appropriate external resource editor applications. And CodeFlow also supports resource update by drag-and-drop.

Local Lua Context

A Local Lua Context is a special kind of lightweight target for a CodeFlow project, that executes the project's Lua code inside the CodeFlow IDE. Local Lua Contexts are useful as playgrounds, when you just want to test some code without creating an application for that. Local Lua Contexts have access to a limited set of macOS frameworks and they benefit from the same debug facilities as real target applications.

Configuration required

A Mac running OS X 10.10 Yosemite or higher, with Xcode 7 or higher installed.

Installation

  • Copy the CodeFlow application in the Applications folder.

  • Launch CodeFlow.

  • If you don't have a valid CodeFlow license installed on your computer, the license information window will be displayed. Enter your Celedev username and password (those you use for login on celedev.com) in this window to get a valid license from the server.

    About CodeFlow licenses:
    You manage your CodeFlow licenses from the Celedev website celedev.com. Make sure that you are logged-in and select "Manage Account" in the user menu. This will display your Celedev account page in which you can visualize and manage your CodeFlow licenses.

    And, as CodeFlow is still in beta, you can get a free CodeFlow beta test license by simply registering on Celedev website.

Quick start

To start live-coding your first app with CodeFlow in 3 steps:

  1. Create a new project: open the New Project window (File->New Project… or ⌘N), select a template and set a product name for the application, click on the Next button and select the directory in which the project will be created.

  2. When you see the message The Xcode Target xxx is now configured for this program, open the associated Xcode project (Program->Open Xcode Project or ⇧⌘O), select a target, and run the application.

  3. Switch back to CodeFlow and live-code your app.

Need more information?

Developer documentation for Celedev CodeFlow is available on the Celedev doc page.

Feedback and bug report

We'd love to hear from you. Use the feedback form in CodeFlow (Help->Send Feedback…), and tell us how you use CodeFlow, what you like in it, what we should improve, what feature you want too see in future CodeFlow versions…

For reporting bugs, please use the bug-report form in CodeFlow (Help->Report a bug…).

With CodeFlow feedback and bug-report forms, you write your feedback in a rich-text editor. You can paste code from CodeFlow or Xcode (it will keeps its colors), or images, or add attachmnents of any other kind. You are free. The sole constraint is the size: feedback messages are limited to 64 MB each, so no big movie, but everything else should be fine. :)

License terms

In short, developing with CodeFlow, for a target application running on an iOS device or on a Mac, requires that you are the owner or designated user of a CodeFlow license delivered by Celedev. Naturally, as long as CodeFlow is in beta status, this CodeFlow license is free for all users registered on Celedev's website.

In addition, you can use CodeFlow without a license when developing code in Local Lua Contexts , i.e. as a Lua playground for live-coding experimentations inside the CodeFlow application.

The CodeFlow license agreement can be found in the License Informations window, accessible from the CodeFlow menu in the application.

CodeFlow is Copyright © 2014-2018 Celedev. All rights reserved.

Version history

CodeFlow 1.2.3 (build 278) - 01 April 2018

  • Fixed an issue that could cause project bindings generation to fail with Xcode 9.3.

CodeFlow 1.2.2 (build 277) - 12 February 2018

  • Fixed a bug that could make calling native closures (aka ObjC blocks) from Lua fail under certain conditions.

CodeFlow 1.2.1 (build 275) - 07 February 2018

  • Improved configuration of the associated Xcode project. You shouldn't see anymore messages telling that a library was removed from the Xcode project, and added in it again a few seconds later.
  • Fixed an rare issue causing a dynamic storyboard not to be found when starting a target application.
  • Fixed a bug that could make the link to an external resource in a CodeFlow project disappear when opening the project.
  • Fixed a possible linker error when building CodeFlow target applications with Xcode 7 or 8.

CodeFlow 1.2 (build 272) - 02 February 2018

  • Project Templates and SDK Bindings Libraries:
    • All application project templates now have a Swift 4 option for the associated Xcode project, in addition to the previously existing options: Objective-C, Swift3.x or Swift 2.x.
    • Live storyboard management is now based on a new better StoryboardMonitor Lua module, with a clean and easy interface to declare dynamic view controllers in tour project. Storyboard-based projects templates have been updated to use this new StoryboardMonitor Lua module.
    • CodeFlow 1.2 includes SDK bindings libraries for Xcode 9.2, with support for iOS 11.2 SDK, tvOS 11.2 SDK and macOS 10.13.2 SDK.
    • The naming of enum constants in the SDK bindings has been improved a lot, and is now a good match with the enums naming philosophy in Swift. This change may imply minor adaptation of your existing apps, so we recommend that you have a look at the corresponding Lua SDK bindings files to see the new enum names.
  • Runtime Library:
    • We have changed the way the Lua interpreter manages runtime errors, and most errors are now recoverable. Practically this mean that when a Lua runtime error occurs, you can now (almost) always step to the next line and continue the program's execution gracefully. Previously, the standard Lua error management could make the current method return abruptly with a nil result, which could sometimes cause a crash of the target application.
    • The Lua syntax for for calling the native version of a method has been improved: now can specify the target class in the call, so it behaves as expected when calling the Lua method from a subclass. The syntax is self[MyViewControllerClass][objc]:someMethod(), like for a superclass method call.
  • Lua Code Editor and Live-Update
    • Now passing an incorrect module name to a require call is detected by CodeFlow and managed as an error, so you won't run anymore into Lua module not found errors.
    • Automatic indentation of Lua source code in the editor now goes a step further, and handles handle more code patterns: function arguments, comments, incomplete strings, field-based expressions…
    • Auto-completion has been slightly updated as well, to propose only keywords consistent with the current syntactic context.
    • When the target app is restarted after a Lua source file with its auto-reload flag off has been changed, the current version of this source file is now loaded in the Lua Context. Which is probably what you expect in such a case.
  • Main fixed bugs:
    • We have fixed a few bugs under macOS 10.13, mainly related with display issues in the project window.
    • We have fixed a bug that could cause target apps to stop working in some cases on 32-bits iOS platforms.

CodeFlow 1.1.1 (build 260) - 30 June 2017

  • Xcode 9 support and live app development for the OS SDKs announced during WWDC 2017 earlier this month: iOS 11, tvOS 11 and macOS 10.13.
  • CodeFlow can now run under macOS 10.13 High Sierra.
  • Improved application project templates: this includes a better overall performance during storyboard updates, as well as minor bug fixes and removal of deprecated APIs in some app templates.
  • Improved OS SDK Bindings libraries.
  • Class properties in CodeFlow Lua Object Framework: you can now define properties at the class level in Lua with the exact same syntax and feature set as for instance properties. Lua class properties are of course fully compatible and interoperable with native properties defined in Swift or Objective C. So you can dynamically add class properties in the associated Xcode project and use them (or implement them) in Lua without having to restart the target application.
  • Fixed an error in the generation of the project bindings library, which could sometimes fail when a new CodeFlow project was created.
  • You probably won't regret the mysterious failure message exit status 65 in project Bindings generation : it has been replaced by a much more explicit indication of the Swift syntax errors that caused this error when the associated Xcode project's compilation failed.
  • Fixed the Waiting for connection with CodeFlow modal alert on iOS, which could sometimes stay visible even if the connection was established.
  • Fixed an issue that prevented a target application to be run in standalone mode if it had been launched only once on a device. This was caused by the Lua module and resource cache in the target application that was not correctly configured the first time the app was run.

CodeFlow 1.1 (build 254) - 14 May 2017

  • Flexible source editors layout:
    • Source editors can be split horizontally or vertically to adapt to your personal taste or screen size. The corresponding Split / Close editor commands are located in the View menu and you can change the split direction by pressing the Option key.
    • You can now navigate in your project files in an editor by using the source file path at the left of the editor toolbar.
    • Pressing the Option key when selecting a file in the project's files list or in a source editor (source file path or dependencies menu) opens this file in a secondary editor.
    • The Variable Editor and Lua Console are now hidden when no target is connected, so all the window space can be used for code editing.
  • Improvements in project templates and live storyboard update:
    • Live storyboard update now supports a broader set of view controllers arrangements out of the box. For example, you don't need to write specific project code anymore for updating child controllers of UINavigationController or UITabBarController. And we have fixed some issues causing view controllers to stop showing the updates under certain conditions.
    • Swift 3 project templates: all project templates are now available in 3 native languages: Objective-C, Swift 2.x and Swift 3.
  • Includes SDK Bindings Libraries for iOS 10.3, tvOS 10.2, and macOS 10.12.4 (corresponding to Xcode 8.3).
  • Improved Variable Inspector.
    • You can now hide up-values or masked local variables in any callstack frame.
    • Variable inspector columns are now resizable.
  • Project Files List:
    • Drag & Drop improvements: a CodeFlow source group can now be linked to an external directory by dropping on it a folder from the finder (or from an other application) while pressing the CTRL key (or ALT+CMD).
    • Undoing a Link to External File command on a group (folder) now correctly restore the previous content on the group.
  • Other improvements and bug fixes:
    • Fixed a crash that could occur after searching text in the code editor.
    • Installing an additional SDK Bindings Library from a slow drive (e.g. from a network drive) could make CodeFlow unresponsive until the installation was finished. This is now fixed.
    • And many other smaller bug fixes and internal improvements.

CodeFlow 1.0.3 (build 237) - 30 September 2016

  • Loadable Asset Packages (new!)

    • Asset Packages are groups of Resource Items in a CodeFlow project, that need to be loaded simultaneously in the target application when they change. A typical use is when you update a resource that includes file references to other assets, like a texture image file referenced by a 3D model object. In such cases, the referenced files shall be kept in sync with the referrer resources in the target application, meaning that the entire package has to be updated when any of its contained file changes.
    • CodeFlow 1.0.3 adds the supports for two kinds of Loadable Asset Packages: (1) User-defined loadable assets packages are basically any group in the project files list that you want to be loaded as a package, and you can configure a group as loadable using the files list's contextual menu; (2) Groups with some well-known types are automatically defined as loadable assets packages: in the current version, this category only contains SceneKit assets groups (i.e. folders with a '.scnassets' extension).
    • Seen from the Lua code in your project, there is no difference between accessing to a resource in Loadable Asset Packages and using a simple standalone resource; you just have the additional insurance when you are notified of a resource update, that all other resources in the same package have been updated too. Also, when an Asset Package is updated in the target application, your code will be notified for every subscribed resource in this package, even if the resource itself did not change (because it may have a reference to a file in the package that did change!).
    • In CodeFlow, Loadable Asset Packages are visually identified by a specific green folder icon in the source files list.
  • Support for SceneKit assets, including dynamic update of resources edited in the Xcode SceneKit editor (new!)
    You can now use SceneKit scenes (.scn files), particle systems (.scnp files) ... as dynamic resources in a CodeFlow project. When you save you edits in Xcode, CodeFlow compiles the SceneKit assets package and send it to the target application. There, the corresponding resource handlers are notified of the changes, so they can then handle the necessary refresh actions, like for any other dynamic resource.

  • CodeFlow IDE

    • In the project source files list, two or more items in a group can now have the same name, provided they have different resource types (i.e. provided there can not be any ambiguity when getting these items as resources from a target application).
    • The project source files list now displays the resource type of every resource item, i.e. the type to be used when calling getResource in the Lua code. These types are displayed as a file extensions, but you can of course use UTIs in getResource calls, if you prefer.
    • The project source files list now shows a spinner to indicate that a resource is being (re)compiled.
    • Fixed a bug that affected the image inspector on macOS 10.12 Sierra.
    • Fixed an exception that could occur when undoing multi-lines edits in the Source code editor on macOS 10.12 Sierra.
    • Improved again the Lua syntax auto-completion, fixing a few remaining bad behavior cases.
    • Fixed a rare resource update issue, were a same resource file could repeatedly sent to the target application.
    • Fixed a bug that made the selection of groups without original URL impossible in the source files list.
    • Added credits for Cocoapods/Xcodeproj in the About CodeFlow window. (Sorry I forgot to mention it in previous versions, guys!)
  • CIMLua runtime improvements

    • Dynamically declared native properties now implement type checking and type conversion, so they have the same behavior and usage safety as real native properties. For example, you can not anymore accidentally overwrite a dynamically declared UILabel IBOutlet by writing mylabel = "some text", as it will cause a runtime error and do nothing, until you correct it and write mylabel.text = "some text".
    • Trying to pass an unexpected value to initialize a struct now triggers a runtime error (like in view.bounds = 2). In previous versions, a value with an unexpected type was silently converted into a zeroed struct.
    • Fixed a fatal exception when trying to convert a Lua table with "holes" in it into an ObjC NSArray. Now, holes in the Lua table are respresented as NSNull objects in the NSArray.
    • Improved the performance of Lua module & resource loading when connected to the IDE.
  • SDK Bindings

    • SDK bindings for Xcode 7.3.1 are still embedded in this version, as it seems that most CodeFlow users are still using this version. SDK bindings for Xcode 8.0 and Xcode 8.1 are available as separate downloads.
    • Various improvements in SDK bindings (enforced Lua / ObjC table field name consistency, struct-related improvements, declare class NSKeyedUnarchiver as lock-protected...).

CodeFlow 1.0.2 (build 232) - 04 August 2016

  • Fixed a bug that could disrupt dynamic resource updates in the target application, and could even cause a crash of the target application in rare cases.

CodeFlow 1.0.2 (build 231) - 27 July 2016

  • Automatic creation of Lua action methods when the associated Xcode project is changed (per-Lua-module configuration). So when you add an action method in Xcode (e.g. by control-dragging from an Interface Builder component), the action method magically appears in the corresponding Lua module in CodeFlow and you just have to fill it with useful code!

  • Lua editor usability improvements:

    • Easier type annotations (Type annotations are used for better code-completion of native properties and method names). You can now simply insert a type annotation in your code using the command ⌥⌘T, and auto-completion of class and struct names is working inside type annotations comments. These improvements make type annotations very easy to use where needed in the code.
    • Added brief highlighting of counterpart syntax elements in the Lua editor when you enter code or move the selection. Highlighted elements include the usual set of brackets, and also syntax block delimiters like do, if, while, repeat, function, else, elseif, end, until. Syntax counterpart highlighting can be disabled in the preference window if you don't like it.
    • Much better behavior of Lua syntax auto-completion in the editor (e.g. the automatic insertion of missing strings terminators or of missing closing brackets): previously, syntax auto-completion could get really annoying sometimes by making deletion of the inserted characters or undo quite difficult; this is now fixed and syntax auto-completion should now be a transparent help when entering code. In addition, more syntax auto-completion patterns have been added, and you can now disable syntax auto-completion in the preference window if you don't want it.
    • More accurate code-completion for fields and methods, regarding the proposed default completion.
    • Special characters and emojis are now correctly displayed inside Lua source code (special characters are valid inside Lua strings and comments).
    • Fixed a wrong code indentation when the insertion point was located at the end of the Lua code (which is not unusual when you type code in a new Lua module).
    • Fixed a few cases where two undo steps were needed to undo a single user action (for example after pasting code).
    • Pressing 'tab' when the cursor is in a line's leading whitespace range now moves the cursor to the line's content start.
    • Double-clicking on a comment boundary (-- prefix or block comment delimiters) now select the entire comment.
  • Performance improvements:

    • Highly improved the display performance of Lua source code in the editor.
    • Reduced the frequency of global variables refresh in the Variable Inspector while the target application is running. In previous versions, global variables refresh in debug mode could have a significant impact on CPU and network bandwidth in target applications with intensive code-driven animations, like 3D games. Now, the Variables Inspector is refreshed at most once per second when the target application is running.
  • Improvements in project templates and live storyboard update:

    • iOS project templates now have support for live update of presented View Controllers, like modal sheets or popovers.
    • During a live storyboard update, the saved state of a replaced View Controller is now applied in the replacing View Controller's viewDidLoad method. This makes the state propagation code in your project much simpler, because the controller's views hierarchy is guaranteed to be available when the state propagation code is executed.
    • During a live storyboard update, Root View Controllers (iOS, tvOS) and Window's Content View Controllers (macOS) are now correctly updated, even if their view is not created yet.
    • Live storyboard updates are now coordinated with project bindings update in case an action method has been added to the updated storyboard. This guaranties that the added action can not be triggered before being defined. This comes in addition to the existing coordination in case of added IBOutlet.
  • Lua runtime improvements:

    • Solved an issue causing target applications using SceneKit under iOS 10 to hang when a texture resource was dynamically updated. More generally, classes or frameworks that use a shared lock to protect their internal structure (like SceneKit) can now be declared as such to the CodeFlow runtime, to avoid deadlocks during Lua code execution.
    • You can now specify custom bindings generation options for project bindings libraries: bindings generation options help the bindings generation process to build the Lua version of C / Objective-C APIs. They do this by providing indications that remove ambiguities in C function parameter types, especially when parameters are typed as pointers, and they can dramatically reduce the number of function or methods of the target native API not available to the Lua code in your project. Custom bindings generation options shall be defined in a file named 'CIMLuaBindingsOptions.plist' located in the same directory as the associated Xcode project.
    • Improved robustness when calling Lua methods from native code: if the called method invocation is inconsistent with the corresponding Lua method, this is now detected and managed as a recoverable runtime error.
    • Fixed an rare-but-possible infinite recursion when printing a Lua instance (seen on iOS 10).
    • Fixed an issue that could cause a target application to ignore dynamic updates of native class interfaces when the associated Xcode project was changed, and obliged to restart the target application to restore its expected live-coding behavior.
  • Other bug fixes:

    • Fixed a crash that could occur when parsing the syntax of a Lua module containing emoji or other special characters.
    • Fixed a rare bug in the Lua syntax parser that could cause inconsistent syntax coloring in the Lua code editor.

CodeFlow 1.0.1 (build 221) - 27 June 2016

  • Fixed a crash that could occur if closing a project window when the target popover was opened.

CodeFlow 1.0.1 (build 220) - 22 June 2016

  • Improved Xcode 8 compatibility:
    • Storyboards and xib files now open by default in the version of Xcode corresponding to the selected SDK Bindings Library. For example, double-clicking on a storyboard source item will open it in Xcode 7.3 if the project uses the iOS 9.3 SDK, and in Xcode 8.0 if the project uses the iOS 10 SDK.
    • Fixed spurious storyboard compilation errors, that can occur when Xcode 8 beta is installed.
    • Swift Xcode projects created by CodeFlow project templates are now configured as Swift 2.3 projects when opened in Xcode 8 (so you don't need to migrate them unless you want to use Swift 3.0).
  • Fixed a rare crash that could occur shortly after CodeFlow launch.

CodeFlow 1.0.1 (build 219) - 16 June 2016

  • Support for iOS 10, tvOS 10, macOS 10.12, and Xcode 8.0 beta (8S128d), released during WWDC 2016. (new!)
    • Updated the generation of Xcode project Bindings Libraries to support changes in Objective-C brought by Xcode 8.
    • SDK libraries for iOS 10, tvOS 10, macOS 10.12 are available as a separate download, for size reasons.
    • Adaptations to make CodeFlow work smoothly with Xcode 8.0. (But keep in mind that this Xcode 8 version is a first developer beta, and that it still has bugs, so don't blame CodeFlow for them :-)
  • Minor improvements and fixes in project templates.
  • New Bindings Library icon.

CodeFlow 1.0 (build 217) - 10 June 2016

  • Project templates (new!)
    • With CodeFlow project templates, creating an application project becomes a very simple operation.
    • 9 generic application templates included: 5 for iOS, 2 for tvOS, and 2 for macOS.
    • 4 example application templates included, so that you can play with the code at will, and if you break things up, you can simply create a new project and continue experimenting with it.
  • Live storyboard update (new!)
    • to see your app user interface change in real-time when you add components or set layout constraints in Xcode.
  • Swift support (new!)
    • Easily integrate a CodeFlow project in an application written in Swift.
    • classes, methods, and object properties defined in Swift are visible from Lua.
    • All provided generic application templates include an option to create a Swift-based Xcode project.
  • Lua runtime improvements
    • Lua object properties are now KVC- and KVO-compliant
    • You can now call the original implementation of a native method, even if a Lua method overrides it.
    • You can now use weak references to native objects in your Lua code.
  • Lua Source Editor
    • Code-completion now include methods and properties declared in Objective-C protocols referenced by the current Lua source file.
    • Code-completion of native bridge globals, like objc or struct, are now proposed even if the global has been aliased to a local variable.
    • Type comment annotation, like --[[@type objc.UICollectionViewLayout]] are now taken into account when proposing code completions in the current Lua file.
    • Improved default selected proposal in code-completion suggestions.
    • Improved 'Dependencies' menu in source editor bar, that displays the full hierarchy of classes, protocols and structs referenced in the current Lua file. In addition, selecting a class, class category, protocol or struct in this menu jumps to the corresponding declaration in the relevant bindings file and highlights it.
    • Pasting or uncommenting code now correctly re-indent the corresponding code range.
  • CodeFlow Project & Files List
    • Added a New Empty Project command in the File menu, that creates an empty project with a Local Lua Context.
    • Added support for package-typed resources in a CodeFlow project. This means that you can add a resource of any type to a CodeFlow project and process this resource in the Lua code of your target application.
    • Drag & drop: You can now control how dropped files in the project files list shall behave by using standard modifier keys: use ⌥⌘ to link the resource item to the dragged file, to create an internal copy of the dragged file, or to replace the content of a resource without replacing the existing link. You can also set the default behavior (link or copy) in the CodeFlow preferences.
    • Drag & drop: You can now replace the content of a resource with a file having a compatible content type. For example, you can drop a png file on a resource with a jpeg image content, and see the connected target applications being updated with the new image.
    • A group in a CodeFlow project can now be linked to a directory in the file system. Linking a group means that any change you make to this group in CodeFlow will be reflected in the linked directory (adding or removing a Lua source file or resource, editing a Lua file…). And any change in the linked directory will be immediately visible in the group in CodeFlow. In addition, changes done to a linked group, in CodeFlow or by modifying the linked directory, can now be undone.
      Linked groups in CodeFlow can be used to share Lua code between projects, or to organize Lua code and resources into git repositories/submodules (or equivalent configuration management units for your favorite tool).
  • Code Execution and Debug
    • Projects can now automatically connect to target applications with specific service name patterns. When you create a CodeFlow project from a template, the auto-connect pattern is automatically set for you, based on the new project's Product-Name and Lua-Context-Name, so generally you don't have to set this manually.
    • The initial breakpoint on a starting target Lua Context can now be enabled / disabled on a per-project basis.
    • Lua module reloading does not interrupt you anymore when you are typing code in Lua module with autoload enabled!
    • Continuing execution after stopping in an old code module version, now switches back the code editor to the last edited file.
    • Added keyboard shortcuts and menu commands for debug actions.
    • In Local Lua Contexts, you can now use the debug commands to run a Lua source file, when the Lua Context is idle.
    • Added a Restart Local Lua Context command in the Execution menu.
    • Switching the debug interface to a given connected targets is now possible via the execution menu, or with keyboard shortcuts ⌘1, ⌘2
    • The variable inspector now updates global variables in real time while your application is running (even if it does not stop on a breakpoint).
  • Lua Code and Bindings

    • The new property() Lua function is the new way of declaring object properties in Lua classes. Properties declared using this syntax are flexible and compatible with Objective-C properties and Swift computed properties.
    • Added Lua object introspection methods implementsLuaMethod and implementsLuaClassMethod.
    • More flexible Message/Resource handler parameters. For example, a handler function passed to a Message- or Resource-Handler can now omit the self parameter if not useful.
    • Resource handlers now have an extra resource file URL passed as their last parameter. This allows a resource handler to use the raw resource data if more convenient than using the proposed resource object.
    • Binding Lua files now have a type annotation for block parameters that indicates the expected function prototype. Example:

      function NSString:enumerateSubstringsInRange_options_usingBlock 
                      (range --[[@type struct.NSRange]], 
                       opts --[[@type enum(NSStringEnumerationOptions)]], 
                       block --[[@type function(substring, substringRange, enclosingRange)->stop]])  
          --[[@return nil]] 
      end
      
    • Binding Lua files now indicate required and optional methods of protocols
    • Binding Lua files now declare properties using the new property notation. Example:

      UIView.userInteractionEnabled --[[@type bool]] = property { get = 'isUserInteractionEnabled' }
      UIView.tag --[[@type integer]] = property()
      UIView.layer --[[@type objc.CALayer]] = property { kind = 'readonly' }
      UIView.focused --[[@type bool]] = property { kind = 'readonly', get = 'isFocused' }
      
    • Local Lua Contexts now have an associated SDK Bindings library that shows available frameworks and APIs.
  • CodeFlow Objective-C/Swift API
    • Added method -doLuaSetupIfNeeded that you call on instances of a native class with a Lua extension, if some Lua-specific setup must be done on these instances.
    • Added method -isLuaClassExtensionLoadedForClass: and -isLuaClassExtensionLoadedForClass:withId: to test if a given Lua class extension is loaded.
    • Improved kCIMLuaModuleLoadedNotification, that now contains extensive information about the loaded module and its results. In addition, this notification is now sent for every loaded module (previously it was only sent for Lua modules loaded from the CIMLua API).
    • On iOS, your app can now display a modal dialog while trying to connect to the IDE. Pressing the 'Skip' button in this dialog make the app switch to the embedded Lua code and resource cache.
    • Added nullability annotations in CIMLua.h, for a better coding experience in Swift.
  • Xcode Project Management
    • Better accuracy of the list of frameworks and libraries that need to be linked with the target application.
    • Project bindings generation now gently asks Xcode to write unsaved files to disk, in the associated Xcode project, before checking if a Bindings Library update is needed.
    • After changing the Xcode project, changed methods and properties are available much quicker for code-completion in CodeFlow Lua editor, or for dynamic declaration in the target application.
    • CodeFlow now enforce the consistency between the target platform defined in the associated Xcode project and the SDK Bindings library selected in a CodeFlow project.
  • Misc.
    • New application icon.
    • You can now send feedback or submit bugs without leaving CodeFlow. Select Send Feedback… or Report a Bug… in the Help menu, and write your feedback in the provided rich-text editor. You can add pasted code from CodeFlow (it will keeps its colors), or images, or any other kind of attachments. You are free. The sole constraint is the size: feedback messages are limited to 64 MB each, so no big movie, but everything else should fit in.
    • Updated user license agreement.
    • Updated the 'About CodeFlow…' window that list the main Open Source components used by CodeFlow.
    • Updated internally the Sparkle framework to version 1.14.0 (For information, CodeFlow use https for updates, and was therefore not vulnerable to the security issue fixed by this version, but it is always good to stick to a recent version :-).
    • CodeFlow now include bindings libraries for the SDKs available in 7.3.1 (iOS 9.3, tvOS 9.2, macOS 10.11.4).

CodeFlow 0.9.20 (build 189) - 27 January 2016

  • Includes SDK bindings for Xcode 7.2 (iOS 9.2, TVOS 9.1, OS X 10.11.2).
  • Fixed bug: calling from Obj-C an init method defined in Lua could fail in some cases.
  • Removed the beta version expiration mechanism in CodeFlow.

CodeFlow 0.9.20 (build 187) - 30 October 2015

  • Support for AppleTV app development, including complete TVOS SDK Bindings Library, and automatic generation of project bindings for your TVOS application.
  • Fixed an issue that caused caused debugger commands to hang in some cases until program execution was resumed.
  • Improved the refresh of the Variables Inspector when the target application is running. Now the effect of any debug command or program change is almost immediately visible in the inspector.
  • included iOS 9.1 SDK bindings, corresponding to Xcode 7.1 (7B91b).
  • Misc. bug fixes.

CodeFlow 0.9.19 (build 185) - 30 September 2015

  • Thanks to a new CIMLua API method, it is now much easier to load asynchronously Lua class extension modules without blocking the application main thread, even when the loaded module is stopped on a breakpoint in CodeFlow! This brings a significant comfort improvement when developing iOS apps with CodeFlow, as an app with a blocked main thread for too long may be killed by the system. Additions in the API include a new method promoteAsLuaObject in protocol CIMLuaObject, used to configure the Lua side of a native object, and a notification kCIMLuaModuleLoadedNotification.
  • Improved and more robust variable names refactoring in the Lua Source Code Editor. Now you rename a variable by alt-double-clicking on it or by selecting the Rename Variable command in the application menu.
  • All commands related to Lua variables selection and navigation are now available from the application menu.
  • Text pasted in the Lua Source Code Editor now has a correct indentation.
  • Fixed a possible text corruption that could occur when undoing complex operation in the Lua Source Code Editor.
  • Updated SDK bindings libraries for iOS 9.0 and OS X 10.11 for Xcode 7.0.1.
  • Various minor bug fixes.

CodeFlow 0.9.18 (build 181) - 16 September 2015

  • Added support for Xcode 7, the iOS 9 SDK and the OS X 10.11 (El Capitan) SDK.
  • Include SDK bindings libraries for iOS 9.0 and OS X 10.11. To limit the size of the CodeFlow image, SDK Bindings for iOS 8.4 and OS X 10.10 are available as separate download if you are still using Xcode 6.4.
  • Bitcode is now included in CodeFlow CIMLua and SDK bindings libraries, making Xcode 7 happy when compiling for an iOS 9 target.
  • Added support for ObjC nullability attributes and generics, when generating project bindings.
  • Added runtime support for nullability attributes: trying to pass a nil value to a parameter declared as non-null now causes a Lua runtime error and stops the debugger where the error occurred.
  • Fixed the warning that could appear in the dsymutil phase when compiling a CodeFlow-based application in Xcode.
  • Fixed a bug that broke the automatic configuration of Xcode projects by CodeFlow if Xcode 7 GM is installed on your Mac.
  • Fixed an issue that could block the live reload of Interface Builder (XIB) documents in the target application.
  • And many other minor bug fixes that would be too long to enumerate here...

CodeFlow 0.9.17 (build 176) - 20 July 2015

  • Easy refactoring of Lua variable names : double-click on a variable to highlight all ocurrences of this variable in the current Lua source file; then click in any highlighted variable occurrence and edit the variable name in every ocurrences at once. To un-highlight variables and stop the refactoring feature, move the insertion point out of the highlighted area or press ESC.
  • New preference to activate / deactivate line wrapping in the Lua source editor.
  • Lua-Enviromnent-aware management of global variables. Now, highlight and refactoring of global variables are consistent with locally-declared Lua _ENV. This globals management also includes other ways to refer to a Lua global variable, like _ENV fields (e.g. _ENV.x) or fields of literal tables assigned to _ENV ( e.g. _ENV = { a = 1, b = "abc" }).
  • The Lua source editor now correcly handles Lua scoping rules for variables used in the condition of a repeat ... until statement.
  • The Lua source editor now keeps multi-lines strings or comments untouched when indenting the code.
  • Minor user interface improvements to the project source files list: a newly created file has its name automatically selected for editing; pressing Enter edits the name of the selected file; pressing Tab moves the focus to the Source Editor; pressing Return opens the file in the default external Editor.
  • You can now synchronize a file system directory and a group in a CodeFlow project's source files list. If a group in a CodeFlow project is linked to a directory in the file system, any change in this group done in CodeFlow will be reflected in the directory and vice versa. This is a straighforward way to create shared libraries containing Lua code or resources for your CodeFlow projects.
  • Improved Drag & Drop from the Finder to CodeFlow: when dragging files to a CodeFlow project, pressing the Alt (option) key now creates a copy of the dragged files in the project instead of creating links to these files in the project. Likewise, when dragging a source item within a CodeFlow project, pressing the alt key will create a copy of this item instead of moving it in the list.
  • Double-clicking on a .lua file in the Finder now opens it in a simple code editor window (instead of creating a new CodeFlow project as in previous versions).
  • Fixed a bug that prevented a code module to be reloaded in the target application when changes followed certain patterns.
  • And many other minor fixes and improvements.

CodeFlow 0.9.16 (build 171) - 18 June 2015

  • OS X App development: CodeFlow now supports live development of Mac apps. The provided features set for OS X apps is pretty much the same as for iOS apps: live application update when code or resources are changed, automatic synchronization with the App Xcode project, run and debug your OS X application on the local machine or on any other Mac visible on the local network, with full access to the OS X SDK and to the Xcode project's APIs…
  • CodeFlow now includes SDK bindings for both iOS 8.3 and OS X 10.10.
  • In a local Lua Context, you can now use classes, methods and types from the (OS X) Foundation and CoreGraphics frameworks, in addition to the standard Lua libraries.
  • Project bindings generation now take into account the "Enable modules" preference in the associated Xcode project.
  • Improved Lua code auto-completion behavior, with less intrusive default completion in many cases and with a number of previously missing completions added to the proposed list.
  • Fixed a bug causing Lua labels to be always detected as a syntax error in the source code editor.
  • And the usual bunch of minor bug fixes.

CodeFlow 0.9.15 (build 167) - 22 May 2015

  • Updated version of the iOS 8.3 SDK Bindings package, that fixes a naming issue affecting a few enum types in the SDK.

CodeFlow 0.9.15 (build 166) - 20 May 2015

  • Live generation of custom Lua Bindings giving access from Lua to data types, functions, methods, classes and protocols defined in the associated Xcode project.
  • Dedicated Bindings Configuration Editor for Custom Binding presents the source header files hierarchy of the associated Xcode project, permits the per-header / per-group selection of header files that will be included in the bindings library, and presents the per-header result of the bindings generation process.
  • Automatic update of Custom Bindings when a source header file changes, or when header files are added to the associated Xcode project.
  • Seamless auto-completion of symbols defined in Custom Lua Bindings.
  • The Dependencies menu in the Lua code editor now includes direct access to Lua API modules defining Obj-C classes and structs referenced by the current Lua file.
  • New version of the included iOS 8.3 SDK bindings library (based on the iOS 8.3 SDK included in Xcode 6.3.2).
  • Bug fixes and minor improvements.

CodeFlow 0.9.12 (build 159) - 9 April 2015

  • CodeFlow now include bindings libraries for iOS 8.2 SDK and for iOS 8.3 SDK.

CodeFlow 0.9.12 (build 158) - 12 March 2015

  • Integration of Bindings for iOS 8.2 SDK (in addition to bindings for iOS 8.1 SDK).
  • Various bug fixes.

CodeFlow 0.9.12 (build 155) - 01 March 2015

  • Added automatic code completion in the Lua source code editor. Code completion proposals appear during typing and can usually be validated with a minimum number of key presses. Automatic completion can be disabled/enabled in the application preferences.
  • Considerably improved the code editor behavior in case of syntax error in a Lua file: code completion now presents field and method names defined after the error location; syntax-aware selection, code coloring and variables highlights, all work in the whole source file in case of syntax error.
  • The Lua command editor now supports callstack-context-aware code completion (and auto-completion). This means that you can very easily write commands including local variables or other symbols available at the line where the selected callstack level is stopped.
  • Fixed a few bugs dealing with Lua syntax highlighting and Lua code reloading in the target application.

CodeFlow 0.9.11 (build 152) - 16 February 2015

  • Fixed a library-search-path issue in the associated Xcode project that could occur when switching from one SDK bindings library to an other.

CodeFlow 0.9.11 (build 151) - 15 February 2015

  • Added support for live-coding an application running on multiple devices simultaneously. This allows to test a live coded app on devices with different screen sizes, hardware capabilities or OS versions without having to switch from one device to the other. A flexible selector, in the toolbar of the CodeFlow project window, displays the connected targets at any given time, and allows to monitor the execution of the Lua program or to execute debug actions on any of the connected targets.
  • More flexible syntax for object initializers in Lua: the return value in an initializer is now optional and can be omitted in most cases.
  • CodeFlow is now optimized for retina display.
  • Local Lua Contexts are now executed in a separate process. This brings a better reliability (a misleading Lua code can not make CodeFlow crash) and improved security (as Lua code runs in a more controlled environment).
  • Fixed a bug when installing a new bindings library, that could cause the new binding library not to be visible until the next launch of CodeFlow.
  • Restored compatibility with application targets running under iOS 6.
  • And many minor improvements and bug fixes.

CodeFlow 0.9.10 (build 148) - 14 January 2015

  • Major improvements in the Variables Inspector:
    • Displays all active variables in Lua call-stack frames, including masked local variables and up-values; masked variables are dimmed, making them easy to identify, but they can be visualized in the source code or edited, just like any other variable.
    • Displays the current Lua environment in a Lua call-stack frame, if different from the Lua global environment. This is a great help to debug programs making use of the powerful Lua _ENV feature.
    • Instant value editing: every variable or table/object field with a value of type string, number, or boolean can now be changed directly in the Variables Inspector.
    • Reliable highlight of changed variables when stepping through the program.
    • And many other usability improvements.
  • Contextual Lua commands execution:
    A command entered in the Lua Console is now executed in the context of the selected call-stack frame in the Variables Inspector. This means that you can execute, from the command console, virtually any piece of Lua code, having read and write access to all local variables, up-values, and free names visible at the current location of the selected call-stack function. You can even use Lua variable arguments ... in your Lua command if the selected call-stack function supports them!
  • Fixed sporadic target-connection issues that could make the connection of a CodeFlow program to a target device hang for a long time.
  • A program using a local Lua Context can now be started with the debug Play button in the toolbar.
  • Printing Objective-C objects or C structs from the Lua console (or from the source code) with Lua print function now produces a significant output.
  • Various bug fixes and minor improvements.

CodeFlow 0.9.9 (build 145) - 17 December 2014

  • Vastly improved handling of C structs in Lua:
    • available struct types are now available in a Lua global table struct;
    • struct values can now be created directly in your Lua code using constructors (e.g. struct.NSRange(0,10);
    • the support of struct methods has been added: a number of standard struct methods are defined natively in the platform SDK bindings libraries and you can define your own struct methods in Lua;
    • CodeFlow now supports autocompletion of struct type names and it automatically adds to the associated Xcode project the iOS frameworks needed for the structs used in your program.
  • Fixed all known causes of CodeFlow crash under OS X 10.10 Yosemite.
  • Improved reliability of the Variables Inspector.
  • Improved Platform SDK management, and better integration with Xcode versions and available iOS SDKs on the host computer.
  • Detection of outdated Bindings Libraries.
  • Many smaller improvements and bug fixes.