The first official release of the Levure application development framework is drawing nigh and I'm looking for help in testing it on various system configurations. For those unfamiliar with the framework I've included the description from the github page below.

I have a test that I would like as many people as possible to run. If you could take a few minutes to try it out and report back that would be great.

# Test: Create a new app

In this test you will use the Create Levure Application stack to create a new application, package it, and test it. Detailed instructions are available at the url below. Please test with LiveCode 8.1.4 Community or Business.

Levure is an application development framework for LiveCode. It helps you organize, develop, and package your application for distribution. It is suitable for intermediate to advanced developers who want to develop cross-platform LiveCode applications.

Why should you build your application on top of Levure? Let's take a look.

### Levure provides a solid foundation for your application

- The framework provides the underlying infrastructure you need to create professional-grade applications on Mac, Windows, iOS, and Android platforms. It allows you to focus on making your application unique and valuable instead of spending time working on features common to many applications. Using the framework saves you time and makes you more productive.
- Includes helpers for adding preferences, managing application windows across sessions, logging, managing recently opened files, opening files and URLs, loading fonts, adding undo/redo, and message broadcasting within the application.

### Levure organizes your application into discrete parts using the file system

- Each library, user interface stack, front script, and back script is an individual file in the file system. Levure gathers everything up when you open your application in the LiveCode IDE.
- You can browse the contents of your application using your favorite file browser.
- You can add stacks and assets to your application by adding them to your application folder.

### Levure uses text-based YAML files for configuration

- The application configuration file is written in YAML (.yml). YAML files which are human readable and don't require you to open up the LiveCode IDE to peruse and edit them. Your file will look something [like this](https://github.com/trevordevore/levure/ ... es/app.yml).
- Define all files that will be packaged with your application for distribution using YAML. Easy to write. Easy to read.

### Levure is efficient when it comes to loading your user interface stacks

- User interface stacks are loaded on an as-needed basis.
- All user interface stacks can be referenced by name, no need to specify the file path.
- Set the destroyStack of your user interface stacks to `true` and they will be removed from memory when closed.

### Levure works with version control systems

- Configuration files are text based.
- Encourages you to use script only stacks for all application logic.
- The only place that traditional LiveCode binary stack files (which are unreadable by version control) need to be used is for the visual user interface. Each user interface stack is stored individually. Once the UI is designed in a binary stack using the LiveCode development environment, the scripts for the stack and its objects are attached as behaviors.
- Create a detailed history of changes made to your application using your favorite version control software. Every change to your code can be recorded and rolled back if necessary.
- Never accidentally save changes made to your code while debugging. Every change is seen by your version control software.
- Work on multiple features at the same time in isolated work areas using your version control software. Only bring the changes into your application when they are complete.
- Have multiple developers work on your project.

### Levure is extensible via Helpers

- A helper is a folder with a configuration file, stacks, externals, modules, and assets.
- A helper adds a specific feature to your application. Just drop the helper folder into your application folder and the new feature is available.
- A helper can make libraries, front scripts, back scripts, externals, modules, or user interface stacks available to your application. Anything that is needed in order to implement the feature can be a part of the helper folder.

## Try it out

Ready to try Levure out? Head over to the [Getting Started](Getting-Started) page.

Well, first off I want to say that, although this is probably meant for someone with far more ability and skill than I currently have, nice work on a very ambitious looking project.

I did work through testing it on a LinuxMint, 18.1, XFCE desktop 4.12 box. I don't develop for ios or android, or even do anything with html5, so those parts I can't really comment on. I did however follow the instructions and it *did* create all the folders it was supposed to, the test app ran, the button clicked, the second window opened and closed.

I didn't try to modify any of the above, as I'm assuming the 'test' was just getting it installed and working.

Some comments on the instructions/process.

1. Not mentioned in the instructions is that after you use the message box to download the initial stack, you have to make sure your in browse mode, not pointer mode, or I suppose you could compile it into an executable after downloading (?).

Although this is probably obvious to everyone else that has regularly used livecode and additions to it for a while, it wasn't readily apparent to me initially. Like I said above, this is probably meant for those it would be readily apparent to

2. Instruction (4) of the create levure app stack says "in a new instance of Livecode ...", which might be considered ambiguous by some. Do you mean close and reopen the IDE ? Do you mean create a new stack? Something else entirely? I couldn't tell, so I opened the stack your directed to in the app folder not knowing whether this was correct or not.

Unfortunately/fortunately, everything else in the instructions worked, but I'm still unsure if I did what the instructions were asking, so if I were developing that next special killer app, it might blow up in my face? I don't know

All of the above aside, as I said initially, it does look like a very ambitious and promising addition to the Lc arsenol.

@bogs - thanks for running the test. I should have moved the description of who Levure is targeted at to the beginning of the post. Levure is targeted at the intermediate to advanced LiveCode developer so I did make some assumptions when putting the test together. I'm glad you were abel to figure things out though.

I've modified the instructions in the stack so that it doesn't mention "a new instance of LiveCode". That part of the instructions is no longer accurate.

Wow. I haven't posted here in years, and was actually about to make a post announcing a rather large project I'm about to kick off, when I saw this thread... I think this is just about exactly what I'm going to need to be able to manage my upcoming project! I've just briefly given it a test drive, definitely will put it through its paces later tonight after I finish getting my development box set up.

Anyway, even only having a quick glance so far, I'm impressed. Aside from being an excellent solution to the "git problem", I can already see a couple of huge ways this is going to help kick off my project. It's something I've had planned for a few years now, with some false starts here and there and a lot of procrastinating. From its conception, I'd already decided that LiveCode would be the only language flexible enough for my needs, especially so with all the really juicy stuff being implemented the last couple of years. The wonderful thing about Levure, just from a quick glance, is that it seems to be the perfect framework for the modular design I've been trying to come up with. When you have a project that has a lot of moving parts, the real challenge is in the way you arrange them all so that they work with each other, yet independently of one another. Never mind the fact that I've got to build several different API & RPC tools, custom NoSQL tools and a unified system for parsing everything that comes back, that's not the stuff that keeps me lying awake at night. I'm not sure if I speak for any other developers when I say this, but the most daunting part of any large project is, at least for me, laying the groundwork. Admittedly, I'm no expert developer, but I like to think I'm smart enough to face any problem. Still, I've been having a hard time thinking my way around my project's basic framework, and boom, here's most of the answer right here in front of me. It's a good feeling to stumble across an actual solution, one that doesn't involve taking crappy shortcuts or just letting things go full spaghetti-mode. I'll probably sleep better, lol.

I've still got a while before I can actually do anything with it (I'm in the middle of nowhere on 3G re-downloading everything), I've got a question in the meantime.. I really like how it uses configuration files, and I already have some ideas how to put this to good use, so long as YAML and JSON can be made to play nice together. I've never worked with YAML, so can you tell me, am I able to encapsulate JSON encoded data in a .yml to pass into (or out of) a stack? Could I do vice-versa? If possible I'd like to be able to stick the configs into MongoDB as well, for instance if I were running several different components of the application on different servers, they get enough instructions from the .yml to tell them to get the rest of their config from the DB...Make sense? My project is going to be heavy with JSON, pretty much every API will use it, the config files for the existing backend are all JSON (with things constantly reconfiguring on the fly, switching components on and off, etc), and will be using MongoDB primarily.

Thanks for this. You are awesome. In the last hour I've gotten a clearer picture of what to do than I have in the last three years! Just think, if your app helps out a goof like me, imagine what a professional can do with it! When I'm able to get started, I'm going crash course it and mock up some backend models with Levure, will report back!

I'm glad Levure resonates with you @fedaykinofdune. I hope it proves as useful to you as you think it will.

fedaykinofdune wrote:I really like how it uses configuration files, and I already have some ideas how to put this to good use, so long as YAML and JSON can be made to play nice together. I've never worked with YAML, so can you tell me, am I able to encapsulate JSON encoded data in a .yml to pass into (or out of) a stack? Could I do vice-versa?

You could embed json data into a YAML file if you wanted to but I don't think you need to go that route. The YAML configuration files are for configuring your application during development. If you have JSON configuration files you can just read those JSON files in with the JSON handlers in LiveCode. I would just stick with whichever format works rather than merging them. Either YAML or JSON will be converted into a LiveCode array.

fedaykinofdune wrote:If possible I'd like to be able to stick the configs into MongoDB as well, for instance if I were running several different components of the application on different servers, they get enough instructions from the .yml to tell them to get the rest of their config from the DB...Make sense? My project is going to be heavy with JSON, pretty much every API will use it, the config files for the existing backend are all JSON (with things constantly reconfiguring on the fly, switching components on and off, etc), and will be using MongoDB primarily.

I would think you could just stick with JSON then. I find YAML easier to write which is why I chose it for Levure. But if you have existing JSON files then I don't know that there is a benefit to combining YAML and JSON together.

fedaykinofdune wrote:Thanks for this. You are awesome. In the last hour I've gotten a clearer picture of what to do than I have in the last three years! Just think, if your app helps out a goof like me, imagine what a professional can do with it! When I'm able to get started, I'm going crash course it and mock up some backend models with Levure, will report back!