Soywiz's PSP Emulator

Release : Soywiz's Psp Emulator 2013-08-15 (r555)

2013-08-15T11:39:00.001-07:00

Improved sasCore so games using it now reproduce notes better
Improved linux/mono speed a lot (there was a bug in the code generation that made function calls 100x slower)
Improved rendering speed. Now 3d games should be faster.

Skinning in hardware
Batch primitive join
Separated component uploading

Fixes on VFPU so Vallhala Knights is now showing skinned characters (still have some issues)
A CWCheat form editor.
Apply HQ2X to textures
View and edit textures with the new texture editor (it generates a .texmap file linked to the executable folder so it will be loaded each time) and you can customize or improve textures.
Added SMAA fullscreen antialiasing.

About the linux version:

Recently I have removed the OpenTK dependency. Now the size of the executable have changed from 9MB to 3MB and also launches MUCH faster. I am trying a native approach trying to using just stuff available on OpenGL|ES so it will be able to run on Android and Chrome's NaCl. One direct problem is that I had to prepare OpenGL context for all the supported platforms. I tried to port it to linux again, but at least in a VirtualMachine I didn't been able to initialize a Opengl 2.0 context.

Could someone with linux experience help me with this? The related file is this one:

https://github.com/soywiz/csharpplatform/blob/master/CSharpPlatform/GL/Impl/Linux/LinuxGLContext.cs

I just get a 1.4 context, so shaders are not compiling.

Cheat editor:

HQ2X textures:

SMAA (disabled/enabled):

Texture editor:

1080p (4x resolution + SMAA + Textures with HQ2X)

Release : Soywiz's Psp Emulator 2013-07-28 (r525)

2013-07-27T17:54:00.003-07:00

New version of the emulator.

Download

http://dfiles.eu/files/96v5zqjej

Changelog:

Updated to .NET 4.5 / Mono 3.x.x
Reimplemented how the CPU dynarec works:

Now generates an AST
Perform some generic optimizations and others related to lwl/lwr that weren't possible before without the AST.
Adds a new window that allows you to see generated functions as C#, IL, XML or MIPS/disassembler.
Branch as local optimization
Native calling/jumping/tail calling with dynamic static fields
Optimized jalr in fors, caching repeated calls
syscalls rewritting to normal calls
direct memory access

VFPU completely reimplemented (now most of the instructions are implemented right)
Faster CSO decoding using the native DeflateStream from .NET 4.5
Huge Speedup related to GPU rendering:

Avoid to write video memory into RAM and then read to the display (now it copies the framebuffer into the display window without transferring data)

Support for scaling the render target (better quality of 3d games and games with bigger 2d textures)
Supports full screen (alt+enter)
Removed the requirement of wavoutput.dll and all that stuff, now it uses MaiAt3PlusDecoder
Added initial support for pmf/h264 videos. It is buggy and doesn't play sound yet. But it is a beggining.
Much more accurate vsync
Lots and lots and zillions of major and minor improvements

Linux notes:

In order to run it in linux, you will need mono >= 3.0 with libgdiplus:

First you have to install a previous version of mono. For example in ubuntu:

apt-get install mono-complete

Then you have to build mono 3.0 and libgdiplus from source:

# libgdiplus 3

apt-get install libcairo-dev libpng12-dev libtiff-dev libgif-dev libjpeg-dev libglib2.0-dev

wget https://github.com/mono/libgdiplus/archive/master.tar.gz

mv master.tar.gz libgdiplus-3.0.tar.gz

tar xzf libgdiplus-3.0.tar.gz

cd libgdiplus-master

./autogen.sh && ./configure && make && sudo make install

# mono 3.2

wget http://download.mono-project.com/sources/mono/mono-3.2.0.tar.bz2

tar -xjf mono-3.2.0.tar.bz2

cd mono-3.2.0

./configure && make && sudo make install

More screenshots:

Example of render target scaling (1x and 2x):

About pspautotests project

2012-12-01T08:48:00.002-08:00

Forgot to write about this last time. I created mid last year a project called "pspautotests". I created it to be able to automatically test features on all psp emulators. I initially implemented it in my emulator, then I ported it to jpcsp. With the developement of the new awesome project ppsspp that started using that project, the work on that project have been increased a lot; lots of new tests, fixed stuff and a new system for the output.
The project have been moved to github: https://github.com/hrydgard/pspautotests/ and anyone can commit new tests.

Since cspspemu, jpcsp and ppsspp emulators are using this project, all the improvements here, will yield in better emulator implementations.

I dropped lot of compatibility with my last changes as I said. I think it was a necessary step-back that will improve speed in next releases and even more in the future when implemented more AST optimizations, that will be a good thing specially when ported to mobile devices. The good thing is that with pspautotests project improving a lot, any regressions introduced with new features or step-backs will be much easyly detected and will be fixed faster.

I want to thank Hrydgard to decide using pspautotests. Thanks!

More WIP work

2012-11-30T16:37:00.000-08:00

I continued the emulator lately. I decided to do a step back and try to rework on the cpu compiler and create a opengl|es plugin in order to be able to port the emulator to mobile devices supporting mono.
So actually the emulator now has less compatibility at this point until I complete/redo some stuff.
I decided to change the way I'm compiling functions to a new way AST-based that will allow simpler+safer micro optimizations. Also it will make code generation simpler and easier to maintain. It will allow to output the AST as C#-like code so you can see what's going on.

I have added a new window that allows you to see compiled functions in several formats (C#-Like, AST, IL, MIPS):

Newer versions will require .NET 4.5. So you won't be able to use it on Windows XP unless you are using mono >= 3.0. Also the new gpu plugin is a OPENGL|ES 2. On windows it will use the angle project. On linux it will use opengl, and on mobile devices it will use the native opengl|es implementation.

On the other hand, lioncash has performed lots of refactorings/cleanups/documentation furthermore to translating the emulator to japanese. Thanks a lot!

Still alive and a new contributor

2012-07-09T01:54:00.006-07:00

The pace of the development slowed down last month. (I didn't have too much time lately). I want to resume my work soon, maybe in a couple of weeks or maybe in my spare time sooner.

About three days ago SsJVasto offered to contribute to the project. So now we are three people on the project: SsJVasto, archanox and me. Due to the free limitations of bitbucket, we decided to continue the work directly on github, and maybe we will change the name of the emulator when we have settled a new name (with collaborators "soywiz's psp emulator" doesn't have much much sense anymore).

I will continue with ILCC until I get ffmpeg compiling directly into .NET in a really portable fashion without wrappers, then I will hook it into the emulator and then I will continue working on the emulator :)

And that's the current status.

More news about ilcc (and a working sample/benchmark) .NET C Compiler

2012-05-19T17:04:00.001-07:00

I have reached a new milestone. I have been fixing bugs and now I can compile and run successfully one of my programs. It is a compression tool, that is great for benchmarking. So I have made a benchmark to test the performance of the .NET code in terms of the native code.

Project:
https://github.com/soywiz/ilcc

You can try the sample by yourself:
https://sites.google.com/site/cspspemu/downloads/comptoe_ilcc.7z?attredirects=0&d=1

Native executables are build using microsoft c/c++ compiler with "cl /Ox" (maximum optimizations).

---

comptoe_ilcc.exe -c3 file.7z file.7z.c3
Encoding[03] file.7z -> file.7z.c3...Success
Elapsed: 1225

---

comptoe_native_cl_x86.exe -c3 file.7z file.7z.c3
Encoding[03] file.7z -> file.7z.c3...Success
Elapsed: 810

---

comptoe_native_cl_x64.exe -c3 file.7z file.7z.c3
Encoding[03] file.7z -> file.7z.c3...Success
Elapsed: 804

---

Also there are more targets:

Available Targets:
yaml - Outputs YAML markup
pinvoke - Outputs .NET pinvoke source with function declarations and structures (not fully implemented yet)
cil - Outputs .NET IL code (not fully implemented yet)
xml - Outputs YAML XML

Besides to generate IL Code, you can generate pinvoke signatures and output the AST as XML or YAML. So it can be used to analyze C code in C# using the library or in other languages outputing to XML.

Executable sizes:

25.088 comptoe_ilcc.exe
16.896 ilcc.Runtime.dll

76.288 comptoe_native_cl_x64.exe
66.560 comptoe_native_cl_x86.exe

At this point runtime lacks lot of stuffs, so it will get larger. For larger projects the runtime will be smaller than the executable and .NET executables get a better compression, so the executables will be smaller than the native executables most of time (at least compressed).

.NET version is just about 50% slower. That's great! It is in the same order of magnitude and it is faster than I initially expected.
So you will be able to run C code on managed .NET (but with unsafe code at this point) platform without recompiling just with a 50% tradeoff (related to the best optimization level CL can get) and without having to port C code to C# by hand.

About the progress and a new awesome (and related) project! : ilcc

2012-05-16T10:50:00.001-07:00

Lately we are commiting much less to the project that before. That's because I'm working on another project. It is a project related to cspspemu. Indeed I started that project to cover an unimplemented area of the emulator in the best possible way: the video decoding part.

So, which project I have started? I tried to port ffmpeg code to C# by hand, and overwhelmed for the titanic work. Other way would have been to create pinvokes for the ffmpeg DLLs, but I don't like the idea since I would like it to be portable. So what's my approach?

To compile ffmpeg into .NET. How? With the project I'm working on:

ILCC

ILCC is a C compiler for .NET. That's it. It can compile C code into .NET IL (also it can parse C programs and output an abstract tree in XML and YAML so it can be used to analyze C code, also it can generate pinvoke declarations).

This project will open lots of doors not just for this project, but to other projects.

Currenly the project has an almost-full-featured C preprocessor, parses most of the C syntax and the code generator is getting better and better (thought at this point it can just compile small and simple programs).

Speed? So you will wonder how it will perform, since C is one of the non-lowlevel fastest languages out there.
As I stated before, C# supports pointers, so we can expect getting speeds of the same order of magnitude.
In fact, I have compiled a fib sample program I made, and performs better in .NET that in native C.
In my machine the .NET version takes 3166ms to complete, and a C native compiled version takes (CL /O2) 4542ms.

.NET executable size: 2kb
Native executable size: 46KB

Maybe .NET handles better tail recursion, but in that case is even faster, and since it support pointers, programs will be probably at a very similar speed.

Of course, .NET can't handle native platform assembler, so the compiler won't support inline asm, and just plain C. So the C version compiled with MMX, SSE, Altivec, or other SIMD extensions etc. support will be faster than the plain C compiled .NET versions.

My goal with that project is to compile the whole FFMPEG project into a .NET portable DLL and use it with the emulator to decode video. DLL will be smaller, and it will be portable.

C is a weird language, with werid syntax and weird stuff, and the .NET compilation won't be easy at all so won't expect to get it working in a few days. But I have done a lot of work already.

EmuReleases.com and new WIP/GIT releases!

2012-05-07T16:44:00.002-07:00

I have created a new site where I will put all the WIP/GIT releases.

http://www.emureleases.com/

I have added in the left side a feed with the lastest builds so you can grab and test them.

You can try the last build:
http://www.emureleases.com/2012/05/git-soywiz-psp-emulator-2012-05-08-r349_08.html

I won't say what includes exactly until the official release, but it can run some more games, and other games that hanged randomly or went slow are now running smoothly.

Tested games:

Puzzle Bubble (WIP BEZIER)
Tales of Eternia (no more hangs)
Astonishia Story (no more hangs)
Breath of Fire III (no more hangs)
Luxor (it seems to run fine)
Phantasy Star Portable (now get into the menus and display some text)
Tekken 5 (now get into the menus)

This includes portuguese and italian translations:

Portuguese: e-COS
Italian: gambe
Spanish: me

Now that you have all the builds, you can try several builds in order to check for regressions.

Release : Soywiz's Psp Emulator 2012-05-03 (r310)

2012-05-03T06:48:00.003-07:00

New version of the emulator.

Download

http://depositfiles.com/files/j4w1vfmkl

This version fixes lots of bugs and adds some news features including linux support.

Changelog:

Added linux support! (tested fedora and ubuntu on x86/x64)

Added ALSA support.
Fixed unsafe memory on linux
Fixed RTC
Better support for x64
Ignoring atrac3+ on linux for the moment

Added a new game manager (now it displays all the isos in a folder) (windows)
Fixed a bug that caused the emulator to hang when trying to open a file before all components are fully loaded (now it waits without hanging)
Fixed problems with GPU synchronization
Lots of code refactorings and cleanups
Improved plugin selector
Implemented a portable way for getting Total Microseconds
Better dependency injection system

Removed HleState
Added new module unittestings

Proper Mt19937 implementation
WIP new function generator (it will allow to inline some functions and to create even better code, creating local variables)
WIP HybridThreading. Allowing to switch between a multithreaded CPU and a more compatible CPU. This will allow to have a HUGE speedup on many games when implemented.
More work on mpeg (still not working but already demultiplexing mpeg streams)
Some GPU fixes
Lots of other changes

Translation notes:

If you want PSP emulator to be in your language, please translate this file, and put the translation here in this blog comments:

File to translate:

https://github.com/soywiz/cspspemu/blob/master/CSPspEmu.Resources/Translations.xml

Thanks.

Linux notes:

I have tested it on Ubuntu 12.04 x86 and Fedora 15 x64:

You can run the emulator using:

mono cspspemu.exe

On some cases you will be able to just double-click the executable.

Ubuntu:

As noticed by martin in the previous post, you can grab mono on ubuntu this way:

sudo apt-get install mono-complete

Maybe you will need too (not confirmed):

sudo apt-get mesa-common-dev mesa-utils mesa-utils-extra

Fedora:

On fedora I have used:

yum install mono-core

ln -s /usr/lib64/libgdiplus.so.0 /usr/lib64/libgdiplus.so

yum install mono-devel

mono-test-install

Download

http://depositfiles.com/files/j4w1vfmkl

WIP : Linux support! : Soywiz's Psp Emulator 2012-04-27 (r264)

2012-04-26T18:19:00.005-07:00

I am making public a WIP and unstable version because this is the first version "supporting" linux. The support is still very experimental, so please, report any problems with this version.

Also it includes some fixes on windows/linux versions and includes a new iso manager for windows:

Please, download this version and report any regression bugs related to this new version.

Linux instructions:

To use it on linux you will need to have MONO installed.

To run the emulator:
mono ./CSPspEmu.exe

On fedora (I have tested it on Fedora 15 LoveCook):
yum install mono-core

If you get an error related to not being able to load gdiplus.dll, try:
ln -s /usr/lib64/libgdiplus.so.0 /usr/lib64/libgdiplus.so
yum install mono-devel
mono-test-install

More information: http://www.mono-project.com/DllNotFoundException

On ubuntu:
apt-get install mono-runtime libmono-winforms2.0-cil mesa-common-dev mesa-utils mesa-utils-extra
(Not tested yet)

New! version compatible with linux and with new iso manager:

Download

http://depositfiles.com/files/wnp9mr7or

Previous stable version:

Download

http://depositfiles.com/files/d3cqm76ig

Release : Soywiz's Psp Emulator 2012-04-07 (r256)

2012-04-07T06:51:00.000-07:00

Download:

http://depositfiles.com/files/d3cqm76ig

This version has major improvements:

Module loading (this allow more games to run, including some software like PRX Decrypter or LUA Player)
Automatical EBOOT decryption. It will decrypt EBOOTs on the fly. This will allow lots and lots of new games to start running. (But still requires some work to get most of them ingame).

Note: with those improvements I have noticed lots of games start running, and some more starting like: Princess Crown and Ys The Ark of Napishtim.

Minor improvements:

Now you can drag & drop executable files on the emulator window
Implemented bltzal/bltzall required for some games
Implemented DXT1
Fixed DX3 R<->B
Added lots of new APIs and fixed some of them.
Added a new versioning system. Releases now are denoted by the date eg: 20120407, git revision: 959572e63973662303c2dfd80f6fb60eaebb4072, and now also a count revision r256. This is an incremental number that indicates the number of commits to the repository.

Some more screenshots:

Download:

http://depositfiles.com/files/d3cqm76ig

New version 2012-04-03

2012-04-02T18:16:00.002-07:00

New version of the emulator!

Download Soywiz's Psp Emulator Version 2012-04-03

News:

A new controller window to allow to remap buttons to keys.
A "recent" list of opened games.
Implemented gpu skinning and morphing.
Lots of fixes on GPU.
Implemented DXT3.
Fixed font reading.
Small fixes and improvements.

New Version with fixes 2012-03-01

2012-03-01T13:12:00.003-08:00

Just a few days after the first release I update it again. I have fixed some stuff that I miss and added some new features.

Download the new version 2012-03-01

Short changelog:

Initial SAS support. Games will play more sounds. It was disabled because of the speed, but now streams the decoded data.
AT3+ loops support. This will avoid the background music to stop.
Fixed the stencil buffer. demos/reflection now works fine.
Fixed some problems when drawing 2D and 3D, that made the 2D to not display. This fixes some homebrew games (like menus of skyroads, dungeon assault...) and probably commercial too.
Regression: Fixed the UID generation to start by 1 instead of 0. That prevented Haruhi from starting. Though still crashes on the mpeg stuff.
Fixed minor bugs
Improved AT3 speed. Instead of loading the whole WAV to memory, streams it. This makes Castlevania to run at almost full speed. (Though it looks really ugly.)
Added a new option in Debug menu to dump geometry in a Waveform .obj file. That dumps the geometry of the current frame to "ms\gpu_frame.obj"
Added a new option to register WavDest in order to be able to play atrac3+ background music. You will still need to install OpenMG.
Added more information on the about box including git commit/facebook/twitter links
Added switches to run the program in commandline. Just run cspspemu /help for more information.
Updated OpenTK
Refactorings and small speedups

New version! Soywiz's Psp Emulator 2012-02-28 (updated)

2012-02-28T13:05:00.001-08:00

Today I release a new version of my emulator. This time it is a completely rewritten emulator from scratch. Now it's written in C# instead of D, and features a dynamic recompilation instead of the old interpreter. Though at this moment the cpu is monothreaded. I will make it optionally multithreaded in the future for games that works fine with multithreading.

Also I have moved to github: https://github.com/soywiz/cspspemu

You can grab the sources with TortoiseGit and compile with Visual C# Express 2010.

And the windows binaries for this version here: Download page

(It will probably work on Linux and Mac in the next versions using Mono because I'm using OpenTK. But at this point mono has some issues with the DynamicMethod generation that keeps it from working.)

Requirements:

It requires .NET Framework 4.0 to start.
"OpenMG Setup Update Program" and "DirectShow's WavDest" to play background music in games. In order to register WavDest: "regsrv32 WavDest.dll"

This emulator features a "fast memory" option that will improve the speed a lot, but it has some issues with some games (though not many), so it's disabled by default. You can check the improvement of using this memory with the minifire (with vsync off) or compilerperf demos.

This is the first public release of the emulator and I have just tested it on my computer, if you have any issue with it, please comment here and I will try to help you.

Information about the release (from the github's README.markdown):

Soywiz's CSharp Psp Emulator

A PSP Emulator for >= .NET 4.0 made in C# by soywiz - Carlos Ballesteros Velasco

Work In Progress emulator

EMULATOR STATUS:

Cpu and Fpu is almost fully implemented
VFpu still has lots of functions without implementation
Audio is implemented
Gpu still requires lots of works
Hle emulation has implemented a basic set of APIs (still lot of work left)
There are lot of homebrew games running
There are a small number of commercial games running

KEY FEATURES:

Fully Managed and Disengaged

Being fully managed (thought it will need unsafe access) will allow to port to lots of platforms in the future: AKA: Linux, Mac, future devices supporting mono/C# unsafe code...

Very Fast Dynamic Recompilation

The quality of the generated code is fantastic.
Lots of MIPs instructions encodes in a single X86 instruction.
The registers are inlined in the CpuThreadState class, so access
to a register is as fast as accessing a non-virtual field.

Fast As Hell Memory Access (Currently on Windows/Linux only)

Using VirtualAlloc/mmap, allows all the PSP Memory Segments to be in a virtual space that fits the PSP Memory.
And since there is no DMA access on a HLE emulation, we can get a pointer just making an ADD operation between the base and the PSP address.
This is as fast as possible.

MainPtr = VirtualAlloc(Base + MainOffset, MainSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);

Very Fast Function Cache

Detect and access to a function cache features O(1),
adding a function cache O(log(n)),
and flushing a range or the whole Function Cache is as fast as possible too.
This is achieved with a Array that contains all the possible memory addresses and a SortedSet
that allows to know which functions have been generated and should be purged when invalidating instruction cache.

Very Fast Thread Switching

Each PSP Thread is a native Green Thread / Fiber. Since the PSP has a single core, and some games requres
thread scheduling, we simulate thread scheduling with fibers. Each PspThread have its own registers in an object,
so instead of restoring the registers, it just resumes the thread execution. Skiping completely the register restoring.
This model also allows to pause the execution of the code at any time very easy, even inside an HleFunction or even
in the future, if we optimize the function generation to detect JAL instructions and call delegates directly, inside
nested function calls.

Very clean HLE Emulation using CustomAttributes, LINQ, method mapping and XML Documentation

LINQ + functional-programming helps to make the code very clean, simple and easy to understand.

/// <summary>
/// Get the size of the largest free memory block.
/// </summary>
/// <returns>The size of the largest free memory block, in bytes.</returns>
[HlePspFunction(NID = 0xA291F107, FirmwareVersion = 150)]
public int sceKernelMaxFreeMemSize()
{
    return HleState.MemoryManager.GetPartition(HleMemoryManager.Partitions.User).ChildPartitions
        .Where(Partition => !Partition.Allocated)
        .OrderByDescending(Partition => Partition.Size)
        .First()
        .Size
    ;
}

C# support of structs and pointers, allow the HLE functions to use pointers directly and seamlessly.

/// <summary>
/// Reads an entry from an opened file descriptor.
/// </summary>
/// <param name="FileHandle">Already opened file descriptor (using sceIoDopen)</param>
/// <param name="IoDirent">Pointer to an io_dirent_t structure to hold the file information</param>
/// <returns>
///     Read status
///     Equal to   0 - No more directory entries left
///     Great than 0 - More directory entired to go
///     Less  than 0 - Error
/// </returns>
[HlePspFunction(NID = 0xE3EB004C, FirmwareVersion = 150)]
public int sceIoDread(int FileHandle, HleIoDirent* IoDirent)
{
    var HleIoDrvFileArg = GetFileArgFromHandle(FileHandle);
    return HleIoDrvFileArg.HleIoDriver.IoDread(HleIoDrvFileArg, IoDirent);
}

Faster than the original PSP, than DPspEmu and than JPCSP

Most CPU/FPU/VFPU operations are something like 8x times faster than the original PSP on a modern computer.
Still the GPU implementation is still limited because of the Cpu <-> Gpu memory BUS. But probably will be enough in most cases.

KISS and DRY

With the "Keep It Simple Stupid" and "Don't Repeat Yourself" philosophies always in mind,
the quality of the core is a priority always over new features.

CPU/Gpu Instruction decoding, assembler and disassembler share a single table with the instruction descriptions that will allow generating the required code on the fly.

    // Arithmetic operations.
    ID("add",    VM("000000:rs:rt:rd:00000:100000"), "%d, %s, %t", ADDR_TYPE_NONE, 0),
    ID("addu",   VM("000000:rs:rt:rd:00000:100001"), "%d, %s, %t", ADDR_TYPE_NONE, 0),
    ID("addi",   VM("001000:rs:rt:imm16"          ), "%t, %s, %i", ADDR_TYPE_NONE, 0),

UnitTesting and Integration Tests

The idea is to create a full set of tests, testing the emulator interface, code generation, and HLE APIs.
UnitTests are integrated in the code, and HLE APIs are external integration tests in form of PSP executables than can be executed on any emulator to test APIs.

Fully Open Source

Project is on GitHub, so anyone can branch the project and perform Pull Requests helping to improve the code.

Created after 4 tries

I'm the creator of the D PSP Emulator. That emulator had 4 versions, every one was created almost from the scratch with different approaches and trying
to improve the quality of the code in each iteration.
The lack of a good IDE, the complicated structure of the D language, the horrible compilation times, caused that it taked too much time for everything,
and made it impossible to refactoring the code without days or weeks of work.
In this time I have learned lot of things, and since the .NET platform is fast enough, have "mono", and solves all my problems with D, it will be my final choice.

Final Words

The first emulator made by Noxa was a C# emulator too. It was for .NET 2.0. .NET and C# have evolved a lot since that 2.0 version. And now it is probably the best
platform/language out there. It has the right balance between ease, power and speed. Of course it lacks some stuff, but it is the language where less programming features I have missed.
I didn't used the pspplayer code as base because I wanted to make things with all the stuff I have learned this time and with a different approach.
I started the first version of my emulator using Noxa's pspplayer as base. I didn't managed to compile his code that time because of a mixed DLL x86/x64, and I wanted to learn to make an emulator.
I want to acknowledge all the great work of Noxa, because

The old D version of the emulator can be found here: old version.

Download page for the new C# version

Official Forums

2011-07-26T04:32:00.000-07:00

Since I have dropped the support of my own forums here, Emunewz have kindly offered a place in their forums. You can access them here: http://www.emunewz.net/forum/forumdisplay.php?fid=136

I will read those forums eventually, but I don't have too much time for that, so it will be only eventually.

MaXiMu will notify me if there is something I have to know so you can ask him too.

Fourth release : D Pspemu r301

2011-07-25T12:36:00.001-07:00

About a year after the last release...
I have been working lately on the emulator again and I have redone lots of its internals. Now it's faster, reliabler and even can run some commercial games!

Astonishia Story

Reduced changelog:

Some commercial games are running! Check our compatibility list, and feel free to add missing games.
New entirely remade multithreaded cpu core!! It will use a native thread per psp cpu thread. So it will get faster on newer cpus with multiple cores. Lots of games have several psp threads, one for the game, other for decoding audio... before this release cpu was executed on a single thread, now it will use one windows' thread per psp thread and executed parallely on multicore cpus withouth any penaly of switching psp threads because it won't switch anything.
Gpu morphing and skinning!
Synchronized components throgh mutex and events instead of polling. (Still not perfect). A better and faster design that eliminates some bottlenecks.
More homebrew compatibility!
Now using eclipse as IDE, using DDT to get autocompletion! Much more productivity.
Cleanups
More APIs implemented
hq2x and output scaling...
Cheats (enabled by command line)
Command line tools for advanced users. "pspemu.exe --help" to see a list of commands.
Lots and lots of work
Background music (Atrac3+ support) with SonicStage (and WaveOut Codec) installed.
And more...

Notes and expectations:

At this moment it has been a single person work.
Still uses a cpu interpreter. Even with multithreading, it will be slower than jpcsp and pcsp on most scenarios where the cpu usage is critical. It will get much faster when implementing the cpu dynarec and one of the fastests out there. I'll do that after getting some more compatibility and after some cleanups.
Still not using shaders. It uses plain OpenGL 1.1 so it has to rebuild every texture whenever clut changes. I will implement shaders later. Also I'm going to check if it's feasible to decode some things like vertex information or color information using OpenCL.
Do not expect getting videos, or getting complex games working at this stage.

Want to help getting this emulator better and better?

Now that I'm using an IDE, and most of the core is fine, the idea of having a team is getting more and more interesting. So:

Did you find a bug? Do you have an idea to improve the emulator? Report it here!
Do you know about the psp's internals or about the psp's kernel api or even emulators and want to learn D? Join us! (Check the FAQ page to find out why D is one of the best choices to make an emulator) Also you can let us know how to implement some X functionality.
Have lots of games and some spare time? Fill up our compatibility database.
Do you know D and want to apply it in a project, or learn how an emulator works or about the PSP platform? Join us!
None of the above but still wanting to help? Please, read the final words.

Final words:

I have a full time work and a very nice girlfriend that requies time, both things takes a lot of time and I can't expend all the time I want on this. I love emulation, but I can't eat and live without money. So I have some commercial projects. The more success of those projects, the more time I will be able to expend on things i love, like emulation.

Currently I have a project I launched with a friend some time ago: kawagames.com.

It's not an affiliate but a website I created to earn some money.
It's a webstore of Indie games. If you like indie games, or if you are an indie developer and want to publish your game there, take a look. We started with only free games, but now we are accepting commercial games too.

So If you are a Indie Game Developer and want to sell your game, don't doubt it. We are preparing the first commercial games before perform advertising on it. More information for Indie Developers.

If you are not interested on indie games, but want to help, you can! Just spread to the world. Maybe some people are interested. There are some great games there people might like.

Also I'm going to donate every three months the 10% of my whole earnings from all my commercial projects to Doctors Without Borders.

More information: http://kawagames.com/solidary // http://www.doctorswithoutborders.org/

Thanks in advance!

--------------

You can download the binaries of the emulator here. And check some screenshots of this version here.

And don't forget to become a fan on facebook! and follow us on twitter!

As always you can follow the changes from google code and download the D Psp Emulator r301 build for windows.

Third release : D Pspemu r164

2010-06-30T11:45:00.000-07:00

After several months, another release of this emulator with a buch of new improvements:

Implemented basic Vfpu stuff!! Now cubevfpu, NeHe and some other demos are working.
GPU speed and compatibility improvements. TRXKICK+Lighting+other fixes and improvements. For example cavestory runs 10fps faster.
Sound enabled by default and could be enabled/disabled while running. Still sounds very bad.
Lots of new NIDs implemented.
Fixed arguments passed to the programs. Now PSPTrist and some other homebrews using arguments start working.
Improved unittesting to avoid regressions.
Added a menu option to associate psp files to the emulator.
Clean ups. Small fixes. And much more...

Again, can't load commercial games, but have much more compatibility with homebrews.

Also, I have created a mini project similar to luaplayer but with the squirrel language. I didn't release it yet, but you can test it in the svn: /extra/squirrel. It has automatic background resource loading. 2D Sprites/Bitmaps+Slicing, TileMaps+A* Pathfinding, IntraFont and Sqlite database. Enjoy.

As always you can follow the changes from google code and download the D Pspemu r164 build for windows.

Second release: D Pspemu r131

2010-04-23T16:29:00.000-07:00

A new version of the emulator with lots and lots of improvements:

Lots of cleanups and improvements in code
Lots of fixes, improvements and new implemented stuff on kernel
Improved unittesting
A lot of fixes of the gpu
Clut implementation for gpu and checks for texture cache
Fixed display and a lot of display/render modes. (Still with some issues)
Some fixes on CLEAR and PRIM gpu opcodes. Now CLEAR is less faked.
Elf relocation
Started to work with dynarec and sound (though it's disabled at the moment)
Take screenshot feature
Small memory viewer (not editable yet) and register viewer
Fixed and implemented more cpu instructions
Added more demos and tests
Autodetection of window's language for the psp's registry.
And much more...!

Still can't load commercial games, but there are much more homebrews running.

As always you can follow the changes from google code and download the D Pspemu r131 build for windows.

Forums and Betatesting

2010-03-29T01:49:00.000-07:00

~~I have started the forums of the project. There is no a lot of content yet, but there they are if someone want to collaborate.~~

~~At the moment I'm not searching developers (until I get the core of the emulator well defined). But still in the meantime betatesting would be very appreciated.~~

The emulator cannot run commercial games yet, but should start running homebrew games. Testing and reporting broken ones would be very appreciated.

Forums can be accessed here

You can use twitter and facebook.

First release: Pspemu r99

2010-03-27T04:23:00.000-07:00

After almost two years, I continued this emulator. With more knowledge about programming and D, I started a new version from scratch in January of this year. It was slow because I have other things to do. But I have been working hardly on it this week and now I have released a version that can run some homebrew. Enjoy!

Website up

2010-03-27T04:17:00.000-07:00

I just started this website to publish news about this emulator.