CoderJoe.net

KDevelop is a full featured IDE for the K Desktop Environment.
In order to take full advantage of the facilities KDevelop has to offer, we’re going to take an existing template based project, and import it as a Makefile project in KDevelop.

In order to do this, first create a template based project as described in the “Using the provided template Makefile” tutorial.

Now that you have your project directory set up it’s time to import the directory into KDevelop and make a KDevelop project file.

To do this, click the “Project” menu, and then the “Import Existing…” to bring up the import existing project dialog. Select the project directory you made in the first part of this tutorial and give the project a name.

For project type you’re going to want to select either “Generic C Project (Custom Makefiles)” or “Generic C++ Project (Custom Makefiles)” your choice of C or C++ doesn’t matter too much at this juncture, so just stick with C. We select “Custom Makefiles” because we want to use the provided nds-example template makefile.

Finally enter your name and e-mail address and click next.
When it asks you if you want to populate the project with files from the source, go ahead and click yes.

You now have a project file for your project directory!
Unfortunately you’re not done yet. If you attempted to compile your project now you’d notice that you wouldn’t get very far. KDevelop will start with a clean environment for the project, so we need to set DEVKITARM and DEVKITPRO in our project.

To do this click “Project” then “Project Options” then select “Build Options” and finally the “Make” tab. There will be a section for environment variables. Add the appropriate variables for DEVKITARM and DEVKITPRO and click “Ok”. At this point your project should now successfully compile!

You could start developing right now, but you’d quickly notice that code completion doesn’t work for types and functions. This is because KDevelop needs to be told where the devkitARM and libnds include files reside.

To set this select “Project” then “Project Options” and choose “C++ Support”. At the bottom of the dialog there is a section for custom “Code Completion Databases” this is really just a collection of paths to the include files you’ll be using to develop your application.

Create one of type “KDevelop Custom Directory PCS Importer” and provide the paths to the devkitARM and libnds include directories. If you followed the environment instructions exactly these should be:

/usr/local/devkitPRO/devkitARM/include
/usr/local/devkitPRO/libnds/include

Click next and name the PCS importer something witty and original like… oh… “NDS Homebrew Includes”.

Click ok and you should now have working code completion!
A word of warning, there is a known issue with the current stable KDevelop (3.2 tree) which causes typedefs for structs of the form below not to work.

typedef struct {
	struct members
} typeName;

Any structs declared as such will not complete correctly. In addition, KDevelop will not code complete #define variables such as the VRAM_A_* types. I have yet to find a way to fix this.

So you can compile and code complete. But I’ll bet my dinner that you want to be able to actually EXECUTE our compiled source so that the “Run” command does what you would expect right? Well, if you’ve installed an emulator you can tell KDevelop to use that emulator to execute your nds file.

To set the emulator as your executable click “Project” and “Project Options” then select “Run Options” enter the full path to your emulator on the executable line, and in the arguments line give the full path to your project NDS file. In most cases this will just be the name of your project directory with .nds at the end. For our helloworld project the resulting file will be “helloworld.nds”.

You now have a full featured KDevelop project!
One word of warning: If you did set an executable in the Run Options, then every time you open up the project options KDevelop will screw this section up. You’ll need to edit the file to remove the “file://” that KDevelop inserts at the beginning.

First follow the instructions for creating a template based project.

Once you have that set up you’re almost finished.
All you need to do is set up the relevant application binds so you can build your project from within Notepad++.

Unfortunately Notepad++ is not an IDE, as such it was not designed to compile applications.
In order to do this we need a few helper scripts that Notepad++ can call to build and clean our project.

I’ve taken the liberty of creating a “build script” to help in this process.

Download the Notepad++ Project Build Helper Script file here and extract its contents to “c:\Program Files\Notepad++\”.
Note: Extracting this archive will remove any existing NppExec scripts you already have defined! Merge the configuration files together if you wish to maintain your existing scripts.

Extracting the archive will set up two NppExec scripts called “Build Project” and “Clean Project”. These two scripts will build and clean the project respectively. In addition it will bind the NppExec run dialog to F8.

Now to compile your project just open a file in your projects source directory, hit F8, select “Build Project”, and click “Ok”

When you run the build script a command console will open in Notepad++ which will display the result of the build.
If there are any errors in the build the errors will be displayed in the console. Individual errors can be double clicked to jump to the line on which the error occurred.

You now have everything you need to develop in Notepad++.

I’m primarily a Linux user, as such I do almost all of my development in Linux either using gVim or KDevelop. Despite my affinity for the aforementioned IDEs and OS I would still be hard pressed to find an IDE better than Microsoft Visual Studio 2005.

This being said, using Visual Studio 2005 with devkitARM and libnds is both simple and a joy. The setup procedure can seem a little daunting (especially if you’ve never had to configure your own Visual Studio project before) but it’s not too bad.

Note: The NDS Example files do come with a Visual C++ project which can be imported, and can be used as a good building block to start a full solution from, however, if we did that we wouldn’t learn anything.

First follow the instructions for creating a template based project.

In order to create a solution you’re going to have to open Visual Studio and import our existing template as a project. Luckily for us Microsoft Visual Studio 2005 has a nifty wizard which will help us with just that.

Click the “File” menu, select “New”, and click “Project from Existing Code…”.
You will be presented with the dialog shown below. You’re going to want to select Visual C++ project as the type and click next.

The next screen allows us to select our project name and directory. Choose the project template directory mentioned earlier as the project directory, ensure that “Add files to the project from these folders” is checked. The project wizard will automatically add the project directory to the list of directories to populate the project with.

Next we get to chose our build system. Make sure to chose external make system and select next.

This screen is where the build magic happens. Lucky for us the amazing people over at devkitPro.org have already devised a simple make/sed combo which will allow the make output to be interpreted by visual studio as error reports it can understand.

The string is: make -r 2>&1 | sed -e ‘s/(.[a-zA-Z]+):([0-9]+):/1(2):/’

This string should be used as both the build command line, as well as the rebuild command line.
Use “make clean” for the clean command line.

Finally use the name of the project directory with .nds at the end as the Debugging output.

Click next, select same as Debug settings, and click finish!
You should now have a working project solution!

You can now build your project and watch as Visual Studio chugs along and builds with our magic build command line. This is fine and dandy, but after a little development you’ll notice that IntelliSense (Microsoft’s proprietary code-completion) doesn’t completely work. In addition you have no way to effectively debug the Nintendo DS applications that have been built.

With a little bit of project configuration you can make IntelliSense work and cause debugging to launch your application in your emulator of choice.

Configuring IntelliSense

To configure IntelliSense you’ll need to add your devkitARM and libnds directories to both the project include directory list.

To get to the list, right click the project icon ( it will be located under the solution in the “Solution Explorer” sidebar ) and select “Properties”.

Once inside of the properties window make sure to select “All Configurations” from the configurations drop-down. Not doing so will cause the changes only to be applied to the Debug release, and changing the setting to Release will produce unexpected results.

Executing your emulator of choice on application debugging

Select the “NMake” category under “Configuration Properties” and select “Include Search Path”.
Clicking “Include Search Path” should make a “…” button visible. Click the “…” to open the Include Search Path edit dialog. Add your Devkit Pro directories to the search path and click ok.

Finally, to set up your emulator to launch on project debug select the “Debugging Category” under “Configuration Properties”.

In this section you should be able to select your emulator command, arguments, and working directory.
Set “Command” to the emulator executable, set the “Command Arguments” to “$(TargetPath)” and set the “Working Directory” to the full path to the executable.

Click ok and you should now have a fully functional Solution complete with IntelliSense and debug to emulator!

Of the different methods for setting up a project, using the provided template Makefiles is by far the easiest.
Packaged with the Nintendo DS examples package that you downloaded (you did download the examples package at my suggestion… didn’t you?) there is a directory called “templates”.

This directory contains a number of template project directories, each designed to make use of the environment variables set during the tool chain install step.

Using these templates is a very simple process.
I will describe how to do this both in Linux and in Windows.
Following in the grandest of programming traditions, lets call our project “helloworld”.

In Linux:

First lets create a directory for our project in our home directory:

mkdir ~/helloworld

Next lets copy over the arm9 template ( I assume you’ve extracted the examples archive to your devkitPRO directory ):

cp -R ${DEVKITPRO}/examples/templates/arm9/* ~/helloworld/

That’s all there is to it!

Each template already comes with a default main.c file containing the equivelent of a hello world application, so you’re ready to go!
To test it, change to the helloworld directory and type make.

cd ~/helloworld/
 
make

In Windows:

The instructions for Windows are almost identical to the instructions for Linux. The only differences between the two are really the Windows style commands and paths.

Create a new folder for your project.

Note: You must make sure that your project directory path does not contain any spaces!
For this reason I would suggest creating a directory under c:\devkitPro called “projects” in which you will put all of your NDS Homebrew Projects.

Once the directory has been created, copy everything inside the directory “C:\devkitPro\examples\nds\templates\arm9″ into your new project directory.

To build your project open a command shell
Start -> Run -> Type “cmd” -> click ‘Ok’

Change directories to your project directory
cd c:\devkitPro\projects\helloworld

type ‘make’

If all is set up correctly in either operating system, when your make process is complete you should find two files one called helloworld.nds and one called helloworld.ds.gba. These two files are for the different respective types of NDS Flash Carts.

If you boot up your new NDS program you will see the drunkencoders.com “Hello DS dev’rs” hello world app!

Congratulations, you have your first project.
For more information read the documentation provided with the example templates, and poke around the provided example code.

UPDATE: Given the updates made in the DevkitPro project since this article was written, it is quite out of date. For Linux, there is a little bit of hope! Commenter Namoul has created an installer script which can be used to get your development environment up and running. Find it here: http://lmn.mooo.com/projects/devkitpro-sh

Well, I realize I had promised to give instructions for both Windows and Linux, but as it turns out, the instructions for Windows are so simple it’s almost laughable.

Are you windows users ready?

Installing devkitARM and setting up your environment in Windows.

1. Run the updater script you downloaded in the previous section.
2. Select devkitARM, libnds, the examples, programmers notepad
3. Finish the install

That’s right. That’s it. You’re done Windows users. Now go have a coffee while us linux users get ourselves up and running.

Installing devkitARM and setting up your environment in Linux and Mac OSX.

To be honest, the process isn’t all that much more complex, but it does assume you know a little bit about setting environment variables.

The first thing you’ll need to do is make sure you’ve downloaded the devkitARM binary package, the libnds source package, and the example code package mentioned in the previous post.

Step 1) Setting up the directory structure:

First we need to set up a development path. This path can be anywhere, but for the sake of this tutorial we’ll assume you’re installing to /usr/local/devkitPRO/.

The first thing we need to do is create our directory structure:
For now this is as simple as

 mkdir /usr/local/devkitPRO

But by the time we’re finished it should look something like

/usr/local/devkitPRO
/usr/local/devkitPRO/devkitARM/
/usr/local/devkitPRO/libnds/

Step 2) Installing the devkitPro binaries:

Next we’ll want to uncompress our devkitARM tar.bz2. Assuming you’ve downloaded the devkitARM archive to your home directory, this can be acomplished by changing to the devkitPRO directory we’ve just created and running:

cd /usr/local/devkitPRO/
tar -xjvf ~/devkitARM_r20-linux.tar.bz2

the devkitARM tar.bz2 contains a root directory called devkitARM which when compressed will contain the toolchain and a series of helpful binaries located within its “bin” directory.

Step 3) Decompress the libnds source:

Next we’ll need to decompress libnds. Unlike the devkitARM archive, libnds does not contain it’s own base directory, so we should create one for it now, and decompress to that directory.

mkdir /usr/local/devkitPRO/libnds
cd /usr/local/devkitPRO/libnds
tar -xzvf ~/libnds-20070503.tar.bz2

Now you have the source and tool chain necessary to build libnds into a fully fledged library for your linking pleasure. Unfortunately, if you’re at all familiar with Linux, you’ve likely already typed make, and to your surprise you’ve received a warning!

We need to set up some environment variables so the makefiles know where the tool chain and other libraries live.

Step 4) Set some environment variables:

First we need to set the DEVKITPRO variable to point to our devkitPRO install directory:

export DEVKITPRO=/usr/local/devkitPRO

Then we need to set DEVKITARM to point to our devkitARM install location

export DEVKITARM=${DEVKITPRO}/devkitARM

To make things easier for me, I just added the following three lines to the bottom of my ~/.bashrc file so every interactive shell would have access to these environment variables.

#Set Variables for DEVKIT_PRO
export DEVKITPRO=/usr/local/devkitPRO
export DEVKITARM=${DEVKITPRO}/devkitARM

Step 5) Compile libnds:

Now that we have our environment variable set, we can compile libnds.
Just go back to our libnds directory and type make!

cd /usr/local/devkitPRO/libnds
make

If all went well, you should see a bunch of text fly by, and eventually successful completion!

Step 6) Bake until golden brown:

Congratulations, you now have a successfully built Nintendo DS development tool chain and libraries.

If you’d like to test your toolchain you can extract the example source tarball that I suggested you download in the previous tutorial, and type make in it’s root directory. If everything is correctly set up, it should create a Nintendo DS ROM for each example in the examples directory.

The examples may not make much sense now, but make sure to poke around the examples. They’re one of the most useful resources a Nintendo DS homebrew developer has at his or her disposal.

Final Notes:

A final suggestion would be to install a Nintendo DS Emulator on your computer if you haven’t already. This way you can begin experimenting with your Nintendo DS examples even if you don’t yet have a DS or development hardware. However, when it comes to testing your shiny new Nintendo DS programs, nothing beats booting them on a Nintendo DS.

I would highly recommend that every budding Nintendo DS developer own at least one Nintendo DS. Besides… when you’re not developing you can pop in your Mario Kart or Tetris cartridge and enjoy Nintendo’s awesome handy-work!

Now that you have a working tool chain set up, you should go on to configure your IDE of choice to use devkitARM and libnds.