Making My First Visual Novel: Little White Lies

This article is about the first New Leaf Journal original visual novel, Little White Lies. As I note below, I recommend reading the novel in your web browser (it is short, even with all six endings) before reading about how I worked with Victor V. Gurbo to bring it to life.

Introduction: Nick and Victor Make and Publish a Visual Novel

As of February 1, 2026, I had published 45 full visual novel reviews on The New Leaf Journal. But while I have reviewed many visual novels going back to Halloween 2020, I had never made a visual novel. But I speak in the past tense. With the release of Little White Lies, I can now proudly add “Visual Novel Developer” to my ever-growing list of titles, which includes, but is not limited to, Editor and Administrator of The New Leaf Journal, Administrator of The Emu Café Social, and the internet’s leading anime hair color anthropologist (TM). Little White Lies is a collaboration between me and my good friend and New Leaf Journal colleague, Victor V. Gurbo. As I will explain below, I was solely responsible for writing the game code and programming and primarily responsible for the script, while Victor came up with the original concept, contributed to the script, handled all of the music with band member and fellow Brooklyn musician, Mark Caserta (not every visual novel first-time developer has the benefit of working with a professional musician), and edited all of the photos (in addition to providing a few from his own photography collection).

Note that this article is about the story of how I worked with Victor to create Little White Lies. I will not discuss the story or gameplay of the game itself in great detail, with one reason being that I do not need to. Little White Lies is free as in bird and available to play in your web browser of choice on itch.io. It takes just a few minutes to play through the game to one of its endings. I will go so far as to say you should read through Little White Lies now and then return to read the story behind it. I will note, however, that it has six endings, so I strongly recommend making use of the game’s save system to make sure you see all of the dialogue and hear all of the music and sounds.

Readers may have questions here. How did Little White Lies come to be? How did New Leaf Journal editor Nicholas A. Ferrell write the code for a working visual novel with multiple endings despite often reminding his readers that he is not a programmer? Fear not, I answer all of these questions below.

The Origin of Little White Lies

Victor and I had kicked around ideas for making a game. In fact, Victor wrote about some early, not finished (or yet-to-be finished?) RPG Maker projects a few years ago. We had also discussed making a visual novel. Of course, it is easier to talk about doing things than actually doing. There were some impediments to us being game designers, namely that neither of us are developers or coders. But despite their being more talking than learning, I have researched different engine tools for writing and building visual novels over the years, with most of my research efforts focusing on Ren’Py, which is free and open source and the most popular engine in the English-speaking visual novel community, and I also focused on ONScripter-EN, which is used by about half of the visual novels I have reviewed on The New Leaf Journal. While I had not made anything with Ren’Py or ONScripter-EN, I knew enough to start on an idea.

Near the end of December, I came across the Gaming Like It’s 1930 contest on itch.io. The concept was simple. In order to be considered for a contest prize, you must submit a digital or analog game that includes a 1930 copyrighted work which entered the public domain on January 1, 2026. For digital games to be considered, they must be playable in a web browser.

I sent the contest to Victor and asked him if we were entering. He said yes. With that settled, we needed a concept. Fortunately, Victor is a musician with a particular interest in folk music, including from around 1930. I counted on him to find a new public domain song we could work with. Victor suggested two-to-three songs, but the first, Little White Lies (originally written by Walter Donaldson and first performed by Fred Waring) struck me as something I could work with as the visual novel script-writer.

• Little White Lies article on Sheet Music Singer with link to the original sheet music.
• Articles noting Little White Lies’ entry into the public domain on Copyright Lately and Wikipedia.

Victor worked on recording his own version of the song while we kicked around ideas for what the game script would look like.

The Early Stages

I started with two pressing issues to resolve: Writing the script and creating a workable game. I was reasonably confident that I could write an acceptable script for Little White Lies in a short time-frame. I was also confident, albeit decidedly less confident, that I could write the code for a working visual novel or choose your own adventure game simultaneously, owing in part to the fact that I had never done so before. My health did not help matters. I was sick for a couple of days not long after Victor and I decided to undertake the project, and I was left with a lingering cough that persisted throughout much of January after I recovered, which did not help my work on Little White Lies (or publishing my regular New Leaf Journal articles).

While I worked on a concept for the script, I researched different engines and tools that I could use to make the game. The specific contest we are entering requires that the game be playable in a web browser, so I limited myself to engines that had built-in functionality to build HTML5 web games. My first idea was to use Twine.js, an engine for making interactive fiction. However, after reading through the documentation for Twine.js and separately the ink scripting language, I decided that it would be easier to implement images and music in a full visual novel engine. My chocie came down to Ren’Py and Tuesday JS. After a quick evaluaton, I settled on Ren’Py for thsi project.

While I was working on the script and programming issues, Victor created the media. Victor recorded Little White Lies, and his band member and regular collaborator, fellow Brooklyn-based musician Mark Caserta (Victor arranged and recorded all of the songs while Mark mixed and mastered the tracks). Victor decided on his own initiative to tweak a couple of lines in Little White Lies, a decision that ended up having a significant effect on my script.

When we settled on Little White Lies, Victor suggested an interesting concept for the game. His idea was that the protagonist would come across an old movie. Little White Lies would be playing over a video, with the video representing scenes from his past romance. The protagonist would see things from the perspective of his past love, and be able to make choices accordingly. Victor suggested chopping up some public domain movies for movie stills. I will note that Victor has made good use of old black and white films in the public domain for his music, see some examples from our discussion about his recent album, Outrun the Invisible Man. While the final game goes in a different direction, aspects of Victor’s original concept still animate our slate of in-game choices.

In drafting the script, I had three priorities.

1. Because I was wearing two hats as scriptwriter and developer, I needed to ensure that the script did not unduly burden me on the developer side of things.
2. The script had to celebrate the original Little White Lies entering the public domain and Victor’s new take on the song.
3. The script must work well in a visual novel format, recognizing that the experience of playing/reading a visual novel is different from reading a short story.

Now before we move on to the next section, allow me to ask and answer two questions.

• Q: When did I finish the draft script?
• A: January 17, 2026.
• Q: When did I create the Ren’Py project that would produce the final game on January 31, 2026?
• A: January 18, 2026.

With that context, we can examine everything in more detail.

The Script

I very much like Victor’s original concept of having a character who is bitter or sad about a failed past love going back in time and seeing things from his past lover’s perspective. Unfortunately, when I sat down with my markdown editor, I lacked a clear and distinct idea of how to turn that concept into a presentable short visual novel based on Little White Lies that I could also handle on the development side of things. But that did not mean that I could not borrow from Victor’s ideas in crafting something that could work on my end.

I drew from inspiration from my own past. Victor and I had a friend back in our college days (he has been referenced in these pages) who always joked(?) that he would disappear without telling us someday (we will call this friend “Jack” although that is not his name). Sure enough, we never heard from Jack after December 2013. If you will allow me to digress for a moment, Jack, like me, was a fan of some of the hold Harvest Moon (now “Story of Seasons“) games released around the turn of the century. In particular, he liked Harvest Moon: A Wonderful Life (“AWL”), which I previously wrote about acquiring and its engrossing concept and game-play. AWL is a unique entry in the long-running series because it is more occupied with marriage and raising a child than any other entry. The original version which Jack and I both played had three eligible young women to marry. While I went for Celia, the sweet farm girl next door, the frriend had gone for Nami, the obviously depressed transient drifter girl (interestingly, he did not go for the bartender, Muffy, after marrying the resident alcohol-loving bachelorette in Harvest Moon 64, Karen). AWL required that the player had to marry by the end of the first year to continue. In the event the player character did not marry Nami, she would leave the town.

I decided to fold this story into a game. Here, the narrator character would describe a woman from his past. He cared deeply for her, and he had the impression she felt the same. He recalls that she had always said she would disappear, but he obviously had not believed she would. But at some point she evidently leaves him, and the the narrator remains behind with only his feelings. The narrator would describe having heard the song Little White Lies when his feelings were still fresh, and upon stumbling upon the song again, he cryptically recalls his past.

In writing the script, I decided that I did not want to say explicitly what happened between the narrator and the woman from his past. I wrote the script in such a way as to invite people who read the game to imagine as they will. The script leaves open many possibilities. With that being said, I did have a clear and distinct idea as writer of the pertinent parts, and Victor had a compelling take about the truth of the matter that is made clear to the reader in one of the final novel’s six endings.

The first draft of my script was very similar to the final version, with most of the changes coming in the way of phrasing and an additional short scene added to the end of each of the six short branching paths. In part one, the narrator recalls the lyrics of Little White Lies while remembering his past with the woman he evidently loved. In part two, he describes stumbling upon a Little White Lies record while cleaning, one he does not recall having seen before (the record jacket has Victor’s face on it, foreshadowing the singer). He then plays the song. When the song finishes, the singer (Victor of course) begins speaking from the record player. Victor asks the narrator several questions about his past based on Little White Lies. The questions are based on two notable differences between the original Little White Lies lyrics and Victor’s version, with Victor asking the narrator which best describes his own experiences. Based on the player’s answers, the game quickly moves to one of six possible endings (note the branches are short and all of the endings occur in the same place, the differences between them come in small dialogue differences).

Victor’s lyrical changes worked out in an interesting way. Victor made the changes on his own accord. After considering the changes, I decided that we could use them as the basis for introducing Victor-as-songwriter into the game itself with an interactive element. We did not coordinate as an initial matter. Victor’s act of songwriter’s discretion inspired my act of scriptwriter’s discretion.

Fortunately, Victor approved of my ideas in the draft script. He made small recommendations regarding phrasing, most of which I adopted, and as I noted previously, I also incorporated Victor’s own view of what happened into one of the six endings (still without telling the reader exactly what happened).

I am reasonably satisfied with the script I was able to draft and refine with Victor on short notice. The style of experimental story-telling I employed is not my visual novel preference. A survey of my ranking of the 31 al|together visual novel localizations will reveal that my favorite pieces generally had well-defined stories that explored interesting ideas and themes intelligently and with appropriate subtlety, although I did hold a few of the more experimental or mechanics-based pieces in high regard. But for a short 10-15 minute project that necessarily needs to celebrate a song written in 1930 and incorporate Victor’s terrific 2026 take on it, I think the dream-like, experimental approach I took works. The game is no more intended to change your perspective on the world than is Little White Lies itself, but I think between Victor’s music, the script, and the interactive elements at the end, it gives the player a good about to think about and enjoy in a short run-time.

The Assets

While I was very confident that I could, working with Victor, produce a respectable script for the novel, and also confident, albeit not quite as confident, that I could produce something that met the threshold for publication using Ren’Py, one big reason I had hope that our project would be worth playing (or reading) was I was working with a professional musician who also moonlights as a skilled photographer. Victor quickly completed his version of Little White Lies and sent me the recording as a .wav file. I think it came out very well, and I invite you to play Little White Lies and watch his music video (we will get to the video in the next section). As I noted above, Victor’s tweaks to Little White Lies helped shape my thinking on both the script and our in-game choices.

While writing the script, I came up with ideas for the images I wanted to see in the novel. Victor considered my requests and provided some excellent photographs he had taken. Consistent with my concept of inviting the reader to picture for him or herself what had happened between the protagonist and his past love, I shied away from using photographs with people. But I ended up using three of the photographs Victor provided (one for the title screen, two for inside the game), all with people, but presented in a hazy, dream-like way consistent with not telling the reader what to imagine. Victor designed a Little White Lies album cover based on an original cover with his face on it, which we use in the game (readers will see I also asked him for a close-up cropped version, which I think I used to great effect) and for the game’s logo. I contributed two of my own photographs to the game, both of which were re-touched by Victor. I also managed to make a 3, 2, 1 countdown in Krita that came out fairly well when we consider the fact that I can barely do anything in Krita.

The “turning point” in the game is when the protagonist puts Victor’s Little White Lies record on. My original concept was to have the music play while we showed an image of the back of Victor’s record jacket with the lyrics. Victor suggested that it would be easier for him to create a video with the lyrics. I was hesitant because I had not planned to implement a video and videos would introduce some potential complications for a web browser-based game, but I agreed to give it a try and I read up on the Ren’Py documentation for implementing videos. We did ultimately go with the video, which I will discuss in the next section. I also used three different no-vocals music tracks — two versions of Little White Lies and one separate piece from Victor — as background music. Finally, I took three sound effects from Pixabay, two of which were for starting and stopping Victor’s record while the third only appears in Victor’s true end.

With the script outline I put together and Victor’s music and photography in order, there was only one thing to do to bring it all together.

Code the visual novel.

Writing the Code

I am neither a coder nor programmer, I just play one on The New Leaf Journal.

I settled on using Ren’Py to create our game. I had read through the Ren’Py documentation before, but as I noted at the top, I never actually worked on a Ren’Py project. But there is a first time for everything, and my first time here happened to start just inside of two weeks from our submission deadline.

Before continuing I will note that while AI-powered vibe coding is all the rage these days, Little White Lies is a human-coded game. I studied the Ren’Py documentation and perused a few blog posts and forum threads to put together a complete project. I have published our four main Ren’Py script files along with the game. While the in-game script and text (save for the public domain lyrics of Little White Lies) and media assets (save for the sound effects, fonts, and menus/text boxes) are copyright protected, I invite people to use my code as inspiration for their own projects or to learn more about how Ren’Py works under the hood (you can play while reading my script.rpy file, which is available for download from the game’s Itch.io page).

With this being my first Ren’Py project, I decided to work in stages, consulting the documentation implementing the most important things (i.e., what we would need for a working final product) first and then gradually adding improvements to a complete and working draft. Because, technically speaking, a visual novel can more or less be complete without much in the way of visuals (see e.g., my review of flanca), I began by implementing the dialogue, followed by the choices. But because it would have been dull to test with a black background, I found a png image of an old blue WordPerfect background and called it at the start of the script.

My initial plan was to make Little White Lies an NVL visual novel, meaning that the text would run from the top of the screen to the bottom, overlaying the background, instead of being confined to a text box at the bottom of the screen (ADV format). Contrast the screenshots from my reviews of May Sky (NVL) and Collage (ADV) to see the difference in practice. Ren’Py’s default setting is ADV, so much of my early reading and testing was centered on digging into how to work in NVL mode. Fortunately, writing dialogue is not difficult in either ADL or NVL mode, and I was able to successfully implement my draft script quickly. Next, I needed to work on implementing our choices. I was pleased to discover that writing choices with very basic branching (i.e., choice a leads to scene y, while choice b leads to scene z) was easy. I estimate that after about few hours of work, I had a working script with dialogue, our final choice structure (the dialogue was tweaked over time), and proper endings returning the player to the title screen.

In those early stages, I decided to mostly abandon my idea of using NVL mode. While it could have worked, I found that setting the proper line spacing in NVL mode for what I was trying to accomplish was unduly troublesome, and ADV mode does have the benefit of better highlighting background images. (A reader noted in an email exchange I had last year that Ren’Py is not the best engine out-of-the-box for NVL games, and I am inclined to agree based on my small amount of experience.)

After we had a working script, I began adding our photographic backgrounds, incorporating suggestions Victor came up with during testing. I was initially unsure how well Victor’s idea for a music video in lieu of background music and a background would work, but I was able to implement the video while following the Ren’Py documentation without too much trouble (Mark recorded the video and Victor added the music and captions). I more or less added 2-3 things at a time, tested to make sure they worked, and then made any necessary improvements following from seeing how the game looked with new additions.

I did much of my heavy-lifting on January 26-28. On the 26th and 27th, I studied Ren’Py’s built-in image transitions, how one scene turns into another, and carefully chose what I thought were the best transitions offered out of the box for our scenes. I added a couple of sound effects from Pixabay. Regarding Victor’s music, I considered timing – specifically how and when the songs started and how they would be phased out. I also added a count-down leading into the music video to ease what had been an abrupt transition.

Prior to January 28, every path in the novel ended almost right after the player answers the last of the singer’s in-game questions. I had told Victor that I tentatively wanted to add an additional scene to all of the routes. With the game mostly in working order and my being fresh off helping push a car out of the snow earlier in the evening, I wrote out a final scene for the novel following Victor’s questions, or I should say I wrote out several versions of the scene with small dialogue differences depending on the player’s previous choices. The ending scene is longer in one case (Victor’s “true end”) in which I implemented an idea based on Victor’s take on my story concept.

I would have liked to be able to change some of the underlying visual novel graphical elements such as menus, menu boxes, and the like. Unfortunately, while I was able to produce a working Ren’Py visual novel, graphic and user interface design is not my area (I like to think I used up my ability on our newsletter mascot), and I did not have time to work with Victor on making new UI elements and testing them before the contest deadline. Thus, all of the text boxes, menus, and buttons are what Ren’Py provides out of the box. However, readers may note that I did change all of the fonts. The dialogue uses PT Serif, character names use PT Sans, the main menu uses Fedoero, and the game choice options use Cagliostro (I chose this “handwriting” font for the choices thanks to a joke in the Ren’Py tutorial game). All of those fonts are freely available on Google Fonts under the SIL Open Font License v1.1 (links are on the game’s Itch.io page).

On January 29, Victor was able to test the January 28 build. He proposed 7-8 dialogue changes, all of which I adopted, noted that the background music did not loop (I fixed, but the tracks are long enough that they should never need to loop in a normal play-through), and suggested transition ideas, which I agreed with and figured out how to implement. By the evening of January 29 (which coincidentally is when I started working on this article), I was more or less comfortable with the state of the game proper. I confirmed the web version worked on Firefox, Chromium-based browsers, and even KDE Falkon (based on QT WebKit) on my Linux workstation. With some difficulty on January 30, I remotely assisted Victor in testing the novel on Safari (I trust Victor greatly enjoyed his first experience starting a local webserver in the MacOS terminal), which resulted in my changing the primary audio format for the web version. (Fortunately, Victor reported that the published game ran as expected in Safari.)

Publishing the Little White Lies to Itch.io

The deadline for submission to the Gaming Like It’s 1930 contest was 3:00 AM (EST) on February 1, 2026. Meanwhile, I still had work to do on January 31. In the early afternoon, my Mom played through our draft and noted a couple of typos, which I resolved. After working on my weekly newsletter and taking a walk, I returned to work in the late afternoon and early evening.

First, I made an itch.io account for the project. While I do have a personal Itch account, I did not want to use that for a collaboration project with Victor. I called our Itch account Circle New Leaf Journal and got it up and running.

After I set up the account, I drafted text for what would be the Little White Lies page on itch.io. I then used a modified version of that text for the “About” menu item inside Little White Lies, which had previously been empty. I will submit here that writing the About text inLittle White Lies was a pain for syntax-formatting reasons (to say writing the About page in Ren’Py was not quite as intuitive as markdown would be the understatement of 2026).

Next, I began filling out our Itch page for the game. I ran into an unexpected problem when I learned that Itch’s preferred aspect ratio for a logo is 630×500, but the logo I had asked Victor to design was 1920×1080, which is a long way from 630×500. Victor would have been able to come up with a new logo quickly, but alas, he was out on Saturday and could not get to a computer. After concluding that I could not turn his logo into a presentable one in 630×500, I cropped the image of his Little White Lies record cover that he created for use in game and used that (fortunately, it works well). After confirming that everything was in order with our game and filling out the required information on the Itch page, I finally uploaded what I thought would be the complete and final build around midnight.

But there was a problem. That problem was the “presplash” screen.

Browser-based games take a small amount of time to load. Ren’Py provides for a presplash screen which shows while the game is loading. One minor complaint I have about Ren’Py is that its presplash screen, a relaxed and happy looking cartoon woman with bubbly text, is not good, not the best. Regardless of one’s opinion about the design, my issue is that it is far too opinionated, in that it looks terribly out of place for certain projects. One such project is Little White Lies. I had foreseen this issue and asked Victor to create a presplash screen, which he did (and did very well). The presplash screen worked when I ran the game locally, and I thought I had it set up for the browser version. Unfortunately, to my dismay, the terrible default presplash screen appeared. While the game itself worked, I could not accept the default presplash screen for it, especially since the game takes 10-15 seconds to load. I dug through the Ren’Py docs and forum to diagnose the problem (note I was tired and beginning to run out of time). I finally figured out that before building Little White Lies for web, I had to put our “web-presplash.jpg” (note it can also be .png or .webp) in the game’s root directory, not the /game directory (which is where the non-web presplash.jpg (or .png/.webp) would go.

The web-presplash issue turned out to be fortuitous in a small way. The recommended method for uploading games to itch.io is a command line program called Butler. I uploaded the first version of our game directly, deciding I did not have time to figure out how to use Butler. However, before uploading the version with the working web-presplash screen, I decided to use Butler – because one benefit of Butler is that it supports incremental uploads (in the event I needed to change something). I installed Butler on my computer from the Arch User Repository, logged in, and after three tries trying to figure out the syntax, successfully uploaded my “fixed” version of Little White Lies. My custom web-presplash appeared. I had won. I made the game public and entered it into the Gaming Like It’s 1930 with less than two hours to go before the submission deadline.

Future of Little White Lies

I consider the web version of Little White Lies a finished project. However, Victor and I will work on creating a version that runs natively on Linux, Windows, MacOS, and Android with some additional features, potentially including voice acting, different audio formats, an image gallery, music room, developer notes, and a screen listing the endings.

I do not foresee dramatically expanding the game, but we may look into adding an additional extra or two.

Conclusion

I hope everyone tries (or tried) Little White Lies. Feel free to tell us what you think on Itch.io or, better yet, our Guestbook. Little White Lies is a simple project made in a short time-frame for a specific event, but it serves as a proof of the concept that I can at least make Ren’Py visual novels with simple structures. While I expect to still review more visual novels than I make, you can expect to find some other New Leaf Journal visual novels in the future.