Revision History

RunScore Revision History (contained in latest full build RunScoreSetup.exe) .

RSServer/RSClient Version Level 2024.02.07

Bug fixes

[RS-1410] Server Connectivity After Incorrect Password Entry

In this release, we have successfully addressed an issue that prevented the Client from reconnecting after an incorrect password entry. Previously, an overzealous security logic terminated the connection and closed the socket, hindering the Client’s ability to re-establish connection in case of a wrong password entry.

Technical details

Issue: The server’s aggressive security logic shut down the socket, thereby preventing the Client from reconnection attempts after an incorrect password entry.


To resolve this issue, we have modified the connection failure logic, ensuring improved handling of incorrect password attempts while allowing the Client to reconnect successfully.


Addressed a bug that allowed connections between different versions of the Server and the Client without warning the user. For example, the Server Version previously allowed connections from Client versions (2021.01.13) – (2023.05.26) without warning, potentially leading to compatibility issues.

[RS-1429] Preventing Data Corruption in Team Downloads

In this release, we have successfully resolved a critical issue that previously led to database corruption during team downloads. The problem arose specifically when the race comprised both regular participants and teams. In this scenario, while the entire team was expected to cover the same distance, each team member ran a shorter individual distance.

Technical details

Issue: The oversight occurred regarding the usage of teams alongside regular participants within the database. The assumption that the database would exclusively contain team records was incorrect.


To address this issue, we have overhauled the logic governing the team download operation. The updated logic now appends the team data to the existing database rather than replacing it entirely. This modification enables teams to coexist seamlessly with regular participant data, ensuring that both types of records are accommodated within the database without compromising integrity.

[RS-1432] Display Issue with Last Lap Time on Announcer Screen

In this release, we have successfully resolved an issue that affected the display of theLast Lap Time on the announcer screen specifically when a back color background was used.

Technical details

Issue: The text color for Last Lap Time, Fastest Lap Time and Average Lap Time was set as the default back color when the when the Average Lap Time was not specified by the user. This caused the Last Lap Time text color to blend with the background, rendering it invisible on a back-colored background.


To rectify this issue, we have enhanced the logic by specifically assigning the text color for each individual element based on user input. This ensures that the color of each text element is displayed according to the user’s preferences, thereby resolving the visibility issue experienced with the Last Lap Time on back-colored backgrounds.

[RS-1437] Fix for File Lookup Crash

In this release, we have successfully addressed and resolved an application crash associated with file lookup. The crash was caused by insufficient parameter sanitization before invoking a Windows fileapi.h function, where the input parameter was derived from user input.

Technical details

Issue: The specific Windows function involved, FindFirstFileA (from fileapi.h), necessitates that the input parameter should not be NULL, an invalid string (e.g., an empty string or a string lacking the terminating null character), or end in a trailing backslash. The existing code lacked adequate sanitization for a few cases, leading to the application crash.


To rectify this issue, we have implemented additional parameter sanitization checks before invoking the Windows API function. These checks ensure that the input parameters meet the required criteria, thereby preventing the occurrence of a crash during file lookup.

[RS-1439] Fix for Chip Data Processing Crash

In this release, we have successfully addressed an issue that previously resulted in a potential crash during chip data processing. This crash occurred when the external timer reported a runner time on a location that was not mapped to the corresponding RunScore time events.

Technical details

Issue: The issue stemmed from chip time information linked to a location that lacked mapping within the RunScore time events. This situation caused the code to encounter a null pointer, consequently leading to a crash.


To resolve this issue, we have implemented changes in the code handling instances where the location information is missing. These alterations prevent null pointer access, thereby eliminating the possibility of a crash during chip data processing.

[RS-1447] Crash on Invalid Entries.ini [Control] Section

In this release, we have successfully resolved a critical issue that caused a crash within the application when encountering an error in the [control] section of the Entries.ini file. Previously, if a user had a SELECT field without an argument, the application would crash instead of providing an informative error message: “Can’t find SELECT field: <argument>.”

Technical details

Issue: The crash stemmed from incorrect initialization of the argument within the [control] section, leading to an access violation in the deblank() method.


To address this issue, we have corrected the initialization of the argument by setting it to an empty string upon encountering such instances in the [control] section. This modification ensures that the application handles such errors gracefully by preventing crashes and provides a clear error message to the user indicating the absence of the required argument for the SELECT field.


[RS-1448] Improved Error Message for Missing Include Files.

In this release, we have augmented the error message handling for missing files within the .include command. Previously, if listing files contained commented lines or comments, the displayed line number did not correspond accurately to the editor line, and the path to the problematic file was truncated.


The error message associated with missing files on the .include command inaccurately presented the file name, line number, and failed command when encountering a missing RSM or other files within the .include command. This issue particularly occurred if there were any commented lines or comments in the listing file.

The error message has been refined to include the following details:
– The missing file would include the race subdirectory information
– The specific command argument that failed
– The complete file path in which the .include command encountered the failure.
– The exact line number.

[RS-1449] Prevention of Heap Corruption for Printer-Specific-Information Class.

In this release, we have implemented additional logic aimed at preventing potential heap corruption for the Printer-specific-information class.


In certain rare cases, when the listing file initiated an email or SMS campaign, it could inadvertently delete the printer-specific-information pointer twice. This action resulted in heap corruption, leading to system crashes or freezes. To mitigate this issue, we have refactored the code to adhere to modern C++ coding best practices, effectively eliminating the possibility of heap corruption within this specific class.

[RS-1466] Improved Handling of Connection Loss Between RunScore and MyLaps.

In this release, we have introduced additional logic to streamline the display of error messages, ensuring the presentation of only one error message for lost connections between MyLaps and RunScore.


This enhancement addresses the issue commonly observed in remote areas with low internet quality, where high traffic or an unstable connection could lead to a dropped TCP/IP connection between MyLaps and RunScore. Previously, each occurrence of a lost connection triggered an error message, resulting in multiple error notifications. This situation was particularly challenging for users, especially when away for an extended period.


We have implemented logic that now ensures the display of a single error message even in the event of multiple occurrences of lost connections. This enhancement aims to streamline user experience by presenting a concise and singular notification, alleviating the burden of managing multiple error messages.

[RS-1473] Auto-Recovery for Socket Interruptions from Windows OS.

In this release, we have introduced a valuable enhancement aimed at addressing socket closures initiated by the Windows operating system. This often results in a connection loss between the Server and Client, especially on systems protected by advanced firewalls or experiencing network corruption.


The issue arises when Windows OS forcibly closes the established connection using an internal function. This is typically observed on networks with corruption or systems with stringent firewall settings.


To mitigate this challenge, we have implemented additional logic to ensure the server can auto-recover from interruptions caused by Windows OS-initiated socket closures. In the event of a failure, the application will now provide users with informative messages, detailing actions that can be taken to resolve the issue. These messages will be based on error codes associated with the interruption.

RSServer/RSClient Version Level 2023.11.16

[RS-1407] Application Crash Resolved When Viewing Results from Client

In this release, we have successfully resolved a critical issue that was causing the application to crash when attempting to view results from the Client. The crash was attributed to memory corruption in the paint function, resulting from improper pointer initialization.

Technical details

Crash Issue: The crash occurred as a consequence of attempting to access a pointer from stack memory outside of its scope, leading to memory corruption and the subsequent crash.


To address these issues, we have modified the memory allocation to heap memory. This adjustment now permits access to the pointer outside of the method, while maintaining its accessibility within the corresponding class.

[RS-1411] Resolved Application Crash Due to Null Point of Read from External Timers.

In this release, we have successfully resolved a critical issue that was causing the application to crash when receiving chip reads from external timers, specifically in cases where a null point of read (event name like “5KSplit”) was sent by the timers, particularly MyLaps.

Technical details

Crash Issue: The crash was triggered when attempting to convert a null pointer into a string. The assumption that external timers would always provide a valid point of read proved to be incorrect.


To address this issue, we have implemented input parameter sanitization. This safeguard ensures that the application can handle cases where null point reads are received without crashing.


[RS-1393,1402] Enhancement: Differentiation of Simple Client (0.6.0) and Fusion (Simple Client 1.2.3)

In this release, we have implemented an important improvement that enhances RunScore’s ability to differentiate between connections from Simple Client (version 0.6.0) and Fusion (Simple Client version 1.2.3). Based on the identified client version, RunScore will initiate connection settings accordingly. Real-time connection status information is now displayed. RunScore can now handle multiple connections, up to 50, with a mix of Simple Client and Fusion on the same port.

  • ChronoTrack connection: Terminated – The connection was was forcibly closed.

  • ChronoTrack connection: Ready – The connection initialization and handshake was successful.

  • ChronoTrack connection: Idle – The connection is active, but Simple Client is not sending any data.

  • ChronoTrack connection: Streaming – The connection is active, and Simple Client is sending data.

  • ChronoTrack connection: Closed – The Simple Client closed the connection.

Additionally, in this release, we have introduced a handler for connection termination/closure. When the connection is terminated/closed, RunScore will promptly close the socket and release all allocated resources, and then re-initiate the server on the given port. This enhancement addresses the previous issue where connection termination rendered Simple Client unable to reconnect to RunScore. These enhancements contribute to more reliable and efficient connectivity with both Simple Client and Fusion versions, ensuring smooth data transmission.

[RS-1421] Enhancement: Improved Handling of Connection Termination/Closure

In this release, we have introduced a robust handler for connection termination or closure in RunScore. When the connection is terminated or closed, RunScore will immediately close the socket, release all allocated resources, and subsequently re-initiate the server on the designated port. This enhancement resolves the previous issue where race closure could prevent MyLaps from reconnecting to RunScore, ensuring a more reliable and seamless reconnection process.

Enhancements Highlights:

  • Efficient Reconnection: The connection will be automatically reestablished within 20 seconds, providing swift reconnection for uninterrupted data transmission.

  • Real-Time Connection Status Display: Users can now access real-time connection status information, offering immediate visibility into the connectivity state, promoting informed decision-making.

    • MyLaps connection: Terminated – The connection was was forcibly closed.

    • MyLaps connection: Idle – The connection is active, but Simple Client is not sending any data.

    • MyLaps connection: Streaming – The connection is active, and Simple Client is sending data.

    • MyLaps connection: Closed – The Simple Client closed the connection.

RSServer/RSClient Version Level 2023.10.30

[RS-1199] Resolved Critical Application Crashes on Closure and Eliminated Ghost Application Issue
  • In this release, we have successfully addressed two critical issues that impacted the stability of the application. These issues caused the application to crash during race closure and resulted in the persistence of a “ghost” application in the task manager after closure. Both problems were related to the proper handling of threads and sockets during application shutdown. These critical bug fixes significantly enhance the application’s stability and overall performance.

Technical details

  • Crash Issue: The crash occurred due to an attempt to retrieve the thread status (owl::TThread). Ghost Application Issue: The presence of a “ghost” application in the task manager was due to a failure to close the listening thread properly.


  • To rectify these issues, the following actions were taken: We have implemented an improved communication mechanism between the main thread and the listening threads. The infinite loop on listening threads has been replaced with a condition loop. The main thread now sets the condition to false and performs a disconnect on each listening socket, allowing each thread to terminate gracefully. The main thread waits for 500 milliseconds before checking the thread status and cleaning up memory.
[RS-1378] Resolved “Live Results” Functionality and Screen Navigation Issues.
  • In this release, we have successfully addressed a bug related to the “Live Results” functionality, which previously displayed a device not ready error when invoked. Additionally, we have resolved issues with screen navigation using the up/down arrows, Page Up/Page Down, and Ctrl+Home/End buttons. In previous versions (2021), pressing any of these buttons would result in an empty screen. With these fixes, “Live Results Lookup” now allows users to navigate as intended. Please check the video .

Technical details

  • Issue: The issue stemmed from the improper usage of memcpy instead of the copy constructor for the results class, leading to errors in the “Live Results” functionality.


  • To rectify this issue, we have added the necessary copy constructor for the results class, ensuring correct data handling. We have also fixed screen navigation for the “Live Results” class by correctly painting the new screen based on user navigation inputs.
[RS-1384] Addressed Application Crash for Exception Handling in Listing Files.
  • In this release, we have successfully resolved a bug that previously caused the application to crash when an exception occurred during the execution of a listing file. Instead of abruptly crashing, the application now correctly informs the user when an exception has taken place, improving user experience.

Technical details

  • Issue: The crash was attributed to a buffer overflow and an improperly formatted string that lacked a null-terminated character.


  • To address this issue, we have taken two key actions: Increased the buffer size to prevent buffer overflows and properly formatted the exception message to ensure it includes a null-terminated character at the end, preventing application crashes and providing clear information to the user when exceptions occur.
[RS-1389] Team Score Export Now Starts from 1st Place.
  • In this release, we have successfully resolved a bug that previously caused team score exports to initiate from 2nd place, leading to inaccuracies in the export results. This issue has been rectified, and team score exports now correctly start from 1st place, ensuring the accurate representation of team rankings.

Technical details:

  • Issue: The bug was attributed to incorrect index usage within a for loop, causing the incorrect numbering of teams in the export, with the 1st team being printed as the 2nd, the 2nd as the 3rd, and so on.


  • To address this issue, we have fixed the index usage and memory corruption. Additionally, we conducted a comprehensive review of related classes to identify and correct similar issues, ensuring the stability of team score exports.
[RS-1305] Added Option to Set Pre-Event to NONE in Event Configuration.
  • In this release, we have introduced a new improvement that allows users to set the pre-event to “NONE” for a specific event. This functionality is accessible through the “Tools” menu, under “Miscellaneous,” and then “Edit list of Events.” This enhancement was made in response to user feedback, with the aim of simplifying configuration for entry-level users, making it more user-friendly.
[RS-1377] Expanded Installer to Include Missing Races.
  • In this release, we have made an important improvement by adding the missing races to the installer package, which now includes the “XCAthleticNet race.” This ensures that the installer will encompass all the races available on our website (“Other Downloads” section)
[RS-1381] Expanded External Timers to Support Up to 8 External Timers.
  • In this release, we have implemented an enhancement by increasing the number of supported external timers from 4 to 8. This change allows the application to better accommodate larger events and simplifies the experience for part-time staff who may not be experts in RunScore. This improvement enables event organizers to rely on a single interface, making it more accessible and user-friendly for new staff.
[RS-1386] View Ignored Chip Reads with Enhanced Data Details.
  • In this release, we have introduced a valuable enhancement that empowers users to view ignored chip reads with enhanced data details. This feature is in response to [RS-1310] from Release and allows users to access and review ignored chip reads through the “Miscellaneous” menu, specifically “View/Edit Ignored Chips.” The data provided will include the bib number, event information, reason, and the raw chip data. Furthermore, with each race open, the application will record a delimiter with the local time and time zone.
[RS-1387] Persistent Start/Stop Flags for External Timers on Auto-Enable.
  • In this release, we have introduced an enhancement that improves the management of External Timers. Now, user selections for Start/Stop flags are persisted, ensuring that when the “Auto enable external timers on start-up” option is enabled in preferences, only the timers marked with “Start” will be initiated. This change offers more efficient resource utilization by running only the selected timers. Previously, in prior versions, all timers would start upon application launch, regardless of user selections.

RSServer/RSClient Version Level 2023.09.27

Bug Fixes:

  • [RS-1335] Resolved the critical issue critical issue that caused the application to crash during the processing of registrations. This crash occurred due to a failure to open the required file. Technical details: Issue: The crash was triggered by an attempt to pass an invalid ifstream object into the JSON reader. Resolution: To rectify this issue, we have implemented logic that checks for the presence of the file and ensures it is not empty, preventing crashes during the processing of registration data. Enhancement: Users will now receive informative notifications if the application encounters any problems while parsing the data, improving the overall user experience.
  • [RS-1376] Eliminated critical issue allowing duplicate bibs in Results Screen (Manual entry only). Technical details: Issue: The bug stemmed from an erroneous assumption that results would always include both bib numbers and times. For manual entries, where the time is zero, the code didn’t handle this scenario correctly. Resolution: To address this issue, we have significantly improved the logic responsible for handling results. The code now correctly manages cases where the time is zero, ensuring that duplicate bibs are no longer allowed in the Results screen, even for manual entries.


  • [RS-1350] Enhanced Singleton Creation and Destruction. In this release, we have focused on modernizing our codebase by significantly improving the creation and destruction processes of singletons within our application. These enhancements align with modern C++ best practices and result in a more robust and efficient codebase.
  • [RS-1368] Enhanced Permission Checks for Application Stability. In this release, we have introduced improvements to our application’s permission checks, particularly concerning the necessity to write temporary files within the race folder. Ensuring proper permissions for this directory is crucial for the application’s functionality and stability. Technical details: The application has been enhanced to perform read and write permission checks for the race directory. If the read and write permissions are not properly set, the application will now inform the user proactively. This prevents crashes and ensures a smoother user experience.
RSServer/RSClient Version Level 2023.09.20


  • [RS-1318] Introduced an enhanced capability that allows for the retrieval of team type names from the RaceRoster API when downloading teams. This improvement was implemented in response to user feedback. Technical details: we have integrated a new API call to RaceRoster specifically designed to fetch “Team type names.”. Subsequently, we have stored this information in a map structure to facilitate quick and efficient lookups.

Bug Fixes:

  • [RS-1223] Resolved the critical issue where the application would crash when a user entered a column name in the browser search field and pressed the Enter key. This crash occurred due to improper processing of user input. Additionally, there is a limitation of three input characters in the search field, and during a downward scroll, the application will now display only the columns that best match the user’s input. Technical details: Issue: The crash was triggered by incorrect user input processing. Resolution: We have fixed the user input processing logic to prevent crashes. Enhancement: Users will now be informed if the entered column name does not exist, improving the overall user experience.
  • [RS-1310] Resolved the critical issue that caused a crash when RunScore received chip data for an unregistered or unknown event. Previously, this crash occurred due to null pointer access during the data processing. As an enhancement, we have added null checks to prevent this issue from happening. Additionally, the application will now inform the user if there are more than 10 invalid chip reads during data processing. Technical details: Issue: The crash resulted from null pointer access during chip data processing for unregistered events. Resolution: We have fixed this issue by incorporating null checks to prevent null pointer access. Enhancement: Users will now receive notifications if there are more than 10 invalid chip reads, allowing for better tracking and management of data processing errors.
  • [RS-1311] Resolved the critical issue related to a runtime crash that occurred when receiving chip times, particularly during the first run of a race. This crash was triggered by an error in the logic, which could lead to a zero memory allocation request. We have rectified this problem by refining the logic and modernizing the initialization of parameters involved. Technical details: Issue: The runtime crash was caused by a logic error that could result in a zero memory allocation request. Resolution: We have resolved this issue by rectifying the logic and adopting {}-Initialization(Modern C++) for initializing the relevant parameters, ensuring a more robust and reliable runtime experience.
  • [RS-1316] Resolved the critical bug causing the Announcer screen to not display names on the Client as they cross the finish line (working correctly on the Server). Technical details: Issue: In version, an issue was introduced into the system when the result processing class was optimized to enhance the processing speed of chip reads. This optimization involved a change in the API of a method, which originally returned “false if succeeds.” However, due to the method being used with a negation in the if statement [if(!methodName())], it led to an unnecessary extra operation. Consequently, a code line was overlooked in the Announcer code, causing the inadvertent discarding of valid data. Resolution: We addressed this issue by correcting the Client’s logic for processing and displaying data received from the Server, ensuring the accurate presentation of participant names. In addition we ensured that all instances where the method is used now adhere to the new API specifications.
  • [RS-1320] Resolved the bug that affected the display of participant gender, where it was erroneously presented as enum values (1, 2, 3) instead of the desired human-readable format (M, F, or X). The root cause of this issue was the absence of a conversion process from the enumeration to a human-readable form. Technical details: Issue: The bug resulted from missing functionality to convert participant gender from an enumeration to a human-readable format. Resolution: To rectify this issue, we have implemented the necessary conversion logic, ensuring that participant gender is now displayed as M (Male), F (Female), or X (Other), as intended.
  • [RS-1322] Resolved the runtime crash issue that occurred when unregistered users attempted to use the system in the trial version. Technical details: Issue: The runtime crash was linked to unregistered users in the trial version and resulted from uninitialized memory that could contain invalid characters. This uninitialized memory was accessed during user validation, creating the potential for a crash. Resolution: To mitigate this issue, we have applied corrective measures, including Modern C++ {}-Initialization, to properly initialize and handle user data. These measures eliminate the risk of a crash and ensure the stability of the system.
  • [RS-1328] Fix the Announcer commands. In the context of lap races, we identified a critical issue with several Announcer commands, including the aforementioned list. The problem originated from a logical error in the decoding process, leading to incorrect interpretation of values. Affected Commands: RECORDS PER PAGE, BACKGROUND COLOR, LAPS LEFT, AVERAGE LAP TIME, LAST LAP TIME, FASTEST LAP TIME, FASTEST LAP, NUMBER OF LAPS, LAPS LEFT, ANNOUNCE UPDATE SEC, ANNOUNCE USE LAST. For more comprehensive information on these commands and their usage, we recommend consulting the help manual. You can access this information by performing a search for “List of Commands” and “Announcer” with the “search titles only” checkbox enabled.Thank you for your understanding, and we trust that these improvements will enhance your experience with our software. Technical details: Issue: The root cause of this issue was traced to the manner in which command values were transmitted. Initially, these values were passed as a single encoded parameter using an unsigned integer, employing the formula cmd_k * 100k. However, as the number of commands continued to expand over time, an integer range overflow occurred. Consequently, the encoded number became smaller, resulting in erroneous values during decoding. Resolution: To address this issue comprehensively, we have implemented a solution by introducing a new Announcer configuration structure. This approach ensures the accurate and reliable transmission of command values, rectifying the bug and enhancing the overall functionality of the Announcer feature.
  • [RS-1340] Resolved the bug related to TFRRS posting, where RunScore was generating an empty JSON output despite the presence of results. This issue was impacting the proper reporting of race data to TFRRS. Technical details: Issue: The problem was attributed to an error in the asynchronous posting process, which resulted in the generation of an empty TFRRS JSON file. Resolution: To rectify this issue, we have made adjustments to the posting process. Specifically, we now store the TFRRS JSON data within the posting thread, ensuring the accurate generation of JSON output and the successful transmission of race results to TFRRS.


  • [RS-1291] Improved Exception Handling for Enhanced Diagnosis. Technical details: In this release, we have made enhancements to our exception handling mechanism to provide a more robust and insightful diagnostic experience. The improvements in exception handling are designed to facilitate better diagnosis of issues, resulting in more effective troubleshooting and issue resolution.
  • [RS-1325] Improved Runtime Memory Checks and Added Extra Memory Corruption Safeguards. Technical details: In this release, we have bolstered our runtime memory checks and introduced additional safeguards to detect and prevent memory corruption. Actions such as “Erase all” or making changes via the “design screen” followed by browsing could potentially result in memory corruption. A permanent fix for memory corruption will be implemented in the next major release.
RSServer/RSClient Version Level 2023.08.30


  • Added new ability to download teams from Race Roster into RunScore in records of teams. Please see the “Teams Download” in the help manual for more detail

Bug Fixes:

  • Fixed the bug when the user was not able to sort results by time or bib. The following error was displayed “Can’t sort empty times” . Technical details: The bug was due to a logical error in the if/else statement. Fixed by correcting the logic.
  • Fixed the crash on race open with an invalid Events.xml file. (Empty pre_event attribute). Technical details: The crash was due to a null pointer access. The application was expecting a valid pre-event. Fixed by null pointer check and display an error message if that was the case.
  • Fixed the crash on entering data in a record field (with template). Technical details: The crash was due to a accessing data outside of the allocated memory. Fixed by checking that the edit point is within the data limits.
  • Fixed the bug that would not post the team results for multiple sets (reported on RunSignUp). Technical details: The bug was due to overriding the send data. Only the last report was posted. Fixed by data synchronization and ownership protection.
  • Fixed the crash on “Import Replace”. The issue only on races without results. Technical details: The crash was due to a accessing null pointer in results system. Fixed by checking the null pointer and returning the 0 times to display.
  • Fixed the bug when the lap time was recorded twice from two distinctive decode devices. Technical details: The bug was due results search and compare logic. The logic was looking only for the first time recorded under the same bib.
  • Fixed by checking all the recorded times associated with the incoming bib.


  • Improved the user experience. On slow internet RunScore will display an error message with bad request. When user is away from the laptop each send error will generate a new messages. That was leading to a cascade of error messages that could “hang up”(Not responding status) the application. The application will display only one error message. Technical details: Added logic to display only one error message if HTTPS send has failed. The logic will ensure that only one error message will be displayed and any given time.
  • Improved the data transfer between RunScore and Fusion. Technical details: Improved the logic that was handling the opening and closure of the connection.
  • Improved the data processing speed. Improved the data transfer between RunScore and Fusion. Technical details: Improved the logic that was handling the opening and closure of the connection. Improved the data processing speed.
RSServer/RSClient Version Level 2023.06.29
  • Added ability to set auto-save of results to be as short as 0.1 minutes (6 seconds). Note: Recommended for laptops with SSD and 11th Gen CPU.
  • Added logs encryption. The RunScore is using BugSlapt as crash reporting system. There are cases when the logs would have personal data(like emails). In order to protect personal data the logs will be encrypted. Added libcrypto-3.dll(File version For more details please see
  • Fixed the crash on Announcer window while the chip data is coming in (active race). Technical details: The crash was caused by by two threads competing over same container. The chip data processing thread was raising with the announcer thread. Fixed by adding the multithreading synchronization.
  • Fixed the look-up from entries.ini. Technical details: The code was ignoring look up c:\runscore\path. Fixed by checking if the look-up is a full path.
  • Fixed the “output to editor” for multiple files introduced in Technical details: When the listing file would call multiple rsm files, then the output would show only the last file. Fixed by performing extra logic on the listing file destenation, to determine if it the user setting should be kept or replaces with a temporary destination.
  • Fixed the partial download issue for RunSingUp for events that had over 1000 participants. Technical details: The RunScore code was incorrectly parsing the incoming JSON. Only the first segment was processed, resulting in a partial download. The bug was affecting only races that had over 1000 participants Fixed the chunk download process for RunSingUp. Reduced the chunk number of participants from 1000 to 250 per request.
  • Fixed memory leak and access violation in results class. Technical details: The class was allocating and deleting the memory multiple times, but the clean up was incorrect used delete instead of delete[]. Fixed by allocating memory number of participants + 10 (bandit records).
RSServer/RSClient Version Level 2023.05.26
  • Fixed the bug when the application was losing the race after RunSignUp download. The application was displaying the error message “Can’t find race. Did you select a race?”  Technical details: The bug was caused by overriding the race file with the one from ESEO registration system. Bug was introduced in version Fixed by removing the override and assigning that the registration system will not affect other registration system files .
  • Fixed the crash caused by invalid chip read. Technical details: The crash was caused by operating with a null pointer. Fixed by adding a null pointer check. Ongoing investigation finding the reason why the chip data is invalid.
  • Fixed the hang on application closure. Technical details: The hang reason is: The listening thread will not terminate the processing of the TCP/IP data while an active “External Timer” connection. Fixed by handling the  accept return on closed socket and best practice thread termination.
  • Fixed the bug when application was overwriting the destination while exporting a listing file. Technical details: The application was overriding the hardcoded user destination with a temporary destination on output to editor. Fixed by checking is the listing file has a destination , if so keep the user setting, otherwise use the default one.
  • Fixed a bug where the application was not downloading the day 1 USAT/USATF registrations. Technical details: The application was comparing against the USAT and USATF string, however RunSignup changed the designation from “USAT” to “USAT Membership”. Fixed by a partial compare of the strings.
RSServer/RSClient Version Level 2023.05.18 (Not Published. Failed QA)
  • Fixed a crash when closing a TCP/IP connection. Technical details: The crash was caused by double-closing a TCP/IP connection. Fixed by assigning INVALID_SOCKET after closesocket and checking that the socket is valid before closing it.
  • Fixed the crash when a race was not selected while posting the results. Technical details: The crash was caused by accessing a nullptr. Sometimes the race object becomes invalid ongoing investigation. Fixed by checking that the race object is valid before attempting to post a result into online system.
  • Fixed the crash while the server was processing inputs from from “External Timers”. Technical details: The crash was caused by by two threads competing over same container. Fixed by adding the multithreading synchronization.
  • Improved the TCP/IP usage by allowing multiple clients to send to the same port simultaneously. Technical details: The TCP/IP implementation was allowing only one connection in the backlog, this was casing a limitation of only one client per port. Increased the backlog from 1 to 50 to allow multiple up to 50 RSClients to send the data(chip reads) to server simultaneously.
RSServer/RSClient Version Level 2023.05.04
  • Fixed a crash when AutoRun was running and manually running other listing files
  • Fixed a crash when AutoRun was running and the import participants from CSV was called
  • Fixed the crash when multiple chip reads were coming at the same time
  • Added additional in-depth logging
RSServer/RSClient Version Level 2023.04.10
  • Fixed a crash that was showing up when the AutoRun function was being used with Lap races
  • Implemented sending of unstructured results to Race Roster from RunScore
  • Added the ability to use the ESEO registration system in RunScore
  • Removed the Race Roster Sub-Event ID from all text outputs
RSServer/RSClient Version Level 2023.01.24
  • Added encoding to special characters when sending data to API endpoints
  • Added the ability to send unstructured results to Race Roster in the form of a text printout
  • Removed Sub-Event ID from all printouts
RSServer/RSClient Version Level 2023.01.25
  • Fix bug with listing file json creation
  • Fix issue with the announce screen when opened from a listing file
RSServer/RSClient Version Level 2023.01.17
  • Fixed an issue with new thread that was causing some users to not be able to post to RaseRoster
RSServer/RSClient Version Level 2023.01.16
  • Added improvements to internal data management
  • Moved Listing file processing to its own thread to relieve some processing from the GUI Thread, increasing its accessibility to the user
RSServer/RSClient Version Level 2022.12.21
  • Fixed an issue that was causing some parameters to be viewed as custom variables in listing files
  • Resolved an issue that was causing a crash when closing a race
  • Added some quality of life code changes to the logging system
  • Moved some connection logic to its own thread when connecting to RaceRoster from a listing file. This was causing a lock up when on very slow connections
  • Added all supported gender types for RaceRoster
RSServer/RSClient Version Level 2022.11.24
  • Added safety check for unusable data being sent from CT Simple Client
  • Fixed a crash that was caused by Erasing All Names
  • Updated the Race Roster Subevent code to work as a parameter between ## symbols in a listing file
  • Updated BugSplat implementation to work with their new system
  • Changed RaceEntry implementation to work with their new API Changes
RSServer/RSClient Version Level 2022.10.18
  • Fixed an issue with empty race names and race dates.
  • Added dynamic resizable dialog boxes to RunScore.
  • Fixed some issue with the logic for fetching participants from Race Roster when doing an Incremental Download in RunScore.
  • Added another fix for Custom-Variables.
RSServer/RSClient Version Level 2022.08.29
  • Fixed an issue with empty race names and race dates.
  • Updated the listing file name length to prevent a crash when the name was too long.
  • Updated some help file documentation.
  • Stopped removing empty lines when parsing listing files.
  • Added functionality to save the race setting more frequently than just when you close RunScore.
  • Fixed USAT membership download issue.
  • Fixed paging issue with RunScore Results.
RSServer/RSClient Version Level 2022.08.05
  • Made improvements to handling custom variables.
  • Update Runscore to use UTC time with RaceRoster.
  • Add “Total” to bottom of the Browse screen.
RSServer/RSClient Version Level 2022.06.30
  • Fixed an issue with downloading participants from RunSignUp whose USAT numbers were not being correctly assigned.
RSServer/RSClient Version Level 2022.06.13
  • Fixed an issue where the age-grade performance for the one-mile run did not agree exactly with that produced by Howard Grubb’s online age-grade calculator.
RSServer/RSClient Version Level 2022.05.17
  • Fixed an issue where downloading from RunSignUp would result in all participants having the same USAT number assigned to them.
RSServer/RSClient Version Level 2022.05.09
  • USAT (United States America Triathlon) membership number was not downloading from RunSignUp correctly as they had changed the race information that was being downloaded.
RSServer/RSClient Version Level 2022.05.06
  • Runscore had capability to check for other events that had pre-event parameters set. This was causing users to have difficulty controlling what events they wanted being run, so now the feature has been removed.
RSServer/RSClient Version Level 2022.04.05
  • Fixed an issue where lines in a header were being eliminated if they started with a blank or a ‘*’
  • Added support for RunSignUp Memberships by handling the membership_id
  • Resolved an issue where the output window would not open in certain cases after running a listing file
  • Fixed an issue where a custom title would not be sent up to RunSignUp when sending results
  • Added support for Non-binary participants when downloading participants from RunSignUp
  • Fixed an issue where the wrong sub-event would be selected from the sub-event selection pop-up when sending results to RaceRoster
RSServer/RSClient Version Level 2022.02.03
  • Fixed an issue where some listing file lines would be executed in @ files even if they were commented out.
RSServer/RSClient Version Level 2022.01.28
  • Fixed an issue where the browse window would shrink every time the window was closed and reopened.
  • Resolved a crash that could happen if all lines in the Listing file were commented out.
RSServer/RSClient Version Level 2021.12.07
  • Added “External Report To” to manual index. The command has been in RunScore for a long time but did not show up
    in the index.
  • Optimized file handling for specific file operations such as the “Output to Editor” function for listing files.
  • Improved stability of the results window when performing actions involving search fields.
  • Corrected the times of the age-grade tables to match the values within the Howard Grubb Calculator.
  • Resolved issues of uploading external/custom reports to ChronoTrack Live.
  • Fixed a paging issue with exporting results to a PDF.
  • Added support of being able to add custom report titles when uploading to ChronoTrack Live.
RSServer/RSClient Version Level 2021.10.06
  • Resolved a rare crash where sometimes RunScore would crash if the first place finisher did not have a ‘Place’
  • Fixed an issue that caused RunScore to crash when viewing results online after uploading to TFRRS
  • Solved an issue that caused duplicates to be downloaded when doing multiple downloads from RunSignUp
RSServer/RSClient Version Level 2021.09.28
  • Resolved the handling of USAT and USATF membership ID’s from RunSignUp.
  • Added support of addons for the RunSignUp Online System.
  • Updated the ‘Destination’ chapter to include all the available exportable file types.
RSServer/RSClient Version Level 2021.09.15
  • Updated the instructions in the help manual on how to correctly configure a SendGrid account for use in RunScore.
  • Added changes to the page’s format in a PDF file to allow manually sized pages.
  • Updated the age grade files to the 2020 standard.
  • Resolved an issue where users couldn’t log into a race on Race Entry and download participants.
  • Improved the handling of transfers streams in ChronoTrack Live Fusion that have multiple active sessions.
RSServer/RSClient Version Level 2021.08.26
  • Changed the implementation of Race Entry to match their API changes.
  • Fixed an issue that caused PDF’s to not be able to be sent to Race Roster.
  • Changed version date format to YYYY-MM-DD to conform more with global standards.
RSServer/RSClient Version Level 2021.08.19
  • Fixed an issue that would occur with races that have laps where RunScore would occasionally crash.
RSServer/RSClient Version Level 2021.08.17
  • Fixed an issue caused by the “Records/Page” command that would cause headers in PDF’s to be displayed at the end of a page rather than the beginning.
  • Made a change to the “MyLaps ProChip” external timer to prepare for an upcoming change to the connection protocol. This change will now notify the user if the external timer has disconnected with the MyLaps Timing
    & Scoring App. This can be enabled by clicking the gear icon in Timing & Scoring of an existing TCP/IP export, then enabling the “Send Ping” checkbox under the Settings tab.
RSServer/RSClient Version Level 2021.06.14
  • Added the ability to create a PDF output from listing files using the Destination, Output To, OR Output Format Commands
  • Added the ability to send a PDF to a Race Roster race
RSServer/RSClient Version Level 2021.05.03
  • Fixed an issue that caused JSON output to fail if participants did not complete the same amount of laps in a lap race.
RSServer/RSClient Version Level 2021.04.19
  • Resolved an issue where memberships were not being downloaded from RunSignUp.
RSServer/RSClient Version Level 2021.03.17
  • This release changes the cumulative time in output of laps race to default format (no fractional seconds). A timer requested requested that the time format used for cumulative times be the same as for split times, i.e. H:MM:SS.

RSServer/RSClient Version Level 2021.02.02

  • This release updates the functionality of the “le number of laps” and “ge number of laps” commands to fix a bug that caused the laps not to be filtered correctly or display appropriate Time and Laps data as expected.
RSServer/RSClient Version Level 2021.01.13
  • This release implements a breaking change to how emails are sent to SendGrid due to a change in the SendGrid authentication protocol. RunScore timers who previously used a username and password to send emails through SendGrid will need to contact Support at to be issued a new username and password with instructions for generating the required api_key that is now used to authenticate email requests to SendGrid through RunScore.
RSServer/RSClient Version Level 2020.12.02
  • This release includes a fix that prevents a deadlock situation from happening when a timer deletes results on the RunSignUp dashboard, but the result set will still be defined in the timer’s race folder.
RSServer/RSClient Version Level 2020.11.03
  • Adds new integration with the BlueBox external timing system
  • RunScore now supports the upload of custom fields to RunSignup. Prior to this change, when a timer did a native upload, only fields that RunSignUp knew about, e.g. “First Name” could be uploaded. By supporting custom fields, now any field can be handled.
RSServer/RSClient Version Level 2020.10.27
  • Timers reported that they were experiencing greater RunScore instability and crashes especially during live races. The cause was traced back to a minor update to the screen refresh rate. This update strictly removes that earlier change.
RSServer/RSClient Version Level 2020.10.21
  • Adds support for RunSignUp custom fields
  • Fixes minor issue that could cause RunScore to hang when initializing a timer
  • Fixes a minor issue that could cause incomplete downloading of participants from when parsing empty or bad input data
  • Removes extraneous RunScore Results login
RSServer/RSClient Version Level 2020.10.05
  • Resolves an issue where a timer received a null error message when uploading results to the TFRRS system. This was caused by a TFRRS ID of one runner that had an extra character (hex ‘A0’) at the end of the id.
  • Minor update to the RunScore logos on server and client
  • Downloading registrations from RunSignUp with an exceptionally long questions caused the question not to be mapped correctly. This has been fixed.
  • Removes the extraneous RunScore Results login protocol (no longer needed)
RSServer/RSClient Version Level 2020.09.17
  • Fixes an issue discovered when timers reported that they were unable to open the sample race files.
  • Adds new functionality to natively handle lap races
  • When selecting to view the timer dashboard at Race Roster, the command now takes you directly to the dashboard
RSServer/RSClient Version Level 2020.08.25
  • Product or Swag mapping from Race Roster was incomplete. This update allows timers to fully map their swag items and options in RunScore.
  • Eventbrite has changed their API to manage users with organizations. RunScore was updated to meet these
  • Fix to include “location” in Results when using the RunScore Open Interface
  • “RunScore Results” is now a deprecated term. References to it have been removed from RunScore. No change in functionality.
  • Fix minor refresh issue when updating an entry in the Browse or  Result window
  • Minor change to insert blanks in non-team-scoring places in cross-country results (when format is JSON)
  • Minor change to remove word ‘rate’ from tri results if no time.
  • Minor change to fix the added “.00” problem in pace for custom report
  • Update to Adding Auto login feature
RSServer/RSClient Version Level 2020.06.30
  • new feature: Controls added to allow user to set Results screen color and font
  • update: allow the download pop-up to be minimized
  • Added new if statements to incorporate the new colors as well as made the changes to the help manual to display those changes.
  • update: RunScore manual adds the Race Roster API information
  • fixes a minor issue that was causing a crash while processing bibs
  • fixes a minor issue that caused a crash when inserting bibs
  • adds age-grade files for 2020
RSServer/RSClient Version Level 2020.04.29
  • introduces new command to set awards being uploaded to Race Roster to record values as “Chip Time” (C)
  • fixes a minor display bug when inserting a new bib in the results screen
RSServer/RSClient Version Level 2020.04.21
  • new feature:  Background and font colors for the entries screen can be set in the entries.ini file
  • following a timer request, participant sorting now sorts blank entries to the bottom
RSServer/RSClient Version Level 2020.04.14
  • new feature:  RunScore now integrates with Macsha Timing Systems
  • new feature: awards can now be uploaded with results to Race Roster
  • adds tcpserver crash fix from Alan
  • updates the help manual
  • fixes browse/edit fields/right-justify problem.
  • fixes problem in RunScore Open Interface (RSBI). This change allows sorting up and sorting down in Browse
  • fixes issue that can cause a crash during client-server communication
  • adds the ability to accept a true or false from a registration platform API
  • implements various changes to improve the stability and memory management of RunScore as a result of reported
    crashes by timers
  • fixes a bug causing bib tags to not be read correctly
  • fixes a bug with listing file print behaviour after uploading awards to Race Roster
  • In response to feedback provided by the timing community, RunScore has now added five (5) new colours for
    listing files
RSServer/RSClient Version Level 2019.12.05
  • We have improved the resilience of the connectivity between the RS client and server
  • We have made a number of changes to improve the security of API communication
  • We have improved the RunScoreUpdate.exe installer to include all required BugSplat files
  • This release implements a number of improvements to memory management to improve the stability of RunScore
RSServer/RSClient Version Level 2019.11.06
  • We resolved a crash related to browsing the List View.
  • We resolved a crash that can occur for Windows 7 users when the latest updates haven’t been installed.
  • We resolved a crash when RunScore would try and attempt to log into an Online Race System.
  • We have fixed a bug related to RunScore trying to process an empty event from a Race which would result in a
  • We resolved a crash related to reloading bib numbers & trimming spaces for fields in the Browse window.
  • This release resolves an issue related to right justification (text alignment) of fields in the Browse window.
  • This release incorporates multiple optimizations and stability fixes.
RSServer/RSClient Version Level 2019.10.24
  • This release resolves a crash in team places when working with team places if invalid data is indexed
  • This release resolves an issue where it was possible to get a crash when navigating through a listing file
  • This release resolves an issue where a crash could occur when sending output to RaceRoster online
  • This release resolves a possible issue when scrolling through a listing file
  • This release selects the first event in the dialog box as default to prevent a possible crash if none selected
  • This release resolves an issue where the upload box could remain open after registrations have competed
  • There was also an issue with the browse field that in certain cases caused the right-justify field to flip to
    left when editing
  • This release also adds numerous improvements to memory management to prevent crashes and improve the stability
    and resilience of RunScore
  • This release makes several performance and resilience improvements to RunScore
RSServer/RSClient Version Level 2019.10.10
  • This release implements a solution for saving updates to records directly from the Browse->EditField dialog.
    This issue was not fully resolved in version
RSServer/RSClient Version Level 2019.10.08
  • This release resolves an issue that occurred during incremental download that caused subsequent events to not
    download results correctly after the first event was downloaded.
  • This release also resolves an issue that caused a crash after a race was automatically opened after being saved
    under a different name or to a new location through RunScore.
  • This release also resolves an issue that occurred sometimes when the browse database view was open while doing
    other tasks in RunScore.
  • This release also resolves an issue where the variable used to identify which race this is in the RunSignUp
    database for RunScore races (RS Races) is interpreted by RunSignUp as a registrant in the RS Races race.
  • This release also resolves an issue where the left-margin command was not working in Team Score.
  • This release makes several performance and improvements to RunScore
RSServer/RSClient Version Level 2019.10.02
  • This release adds functionality to automatically refresh RunSignUp sessions to prevent errors caused by sessions
    timing out.
  • This release makes several performance and improvements to RunScore
RSServer/RSClient Version Level 2019.09.05
  • This release makes several performance and improvements to RunScore
RSServer/RSClient Version Level 2019.08.30
  • This release added a fix to a bug that was causing races larger than one thousand registrants to not be
    downloaded completely form RunSignUp.
  • It also added afix to an issue that was occasionally happening on the client and causing it to crash.
  • Fixed an issue that was causing the header sent to RunSignUp’s API to have extra fields.
RSServer/RSClient Version Level 2019.08.27
  • This release gets rid of merge mode. Now it just uses mapping ini file in race folder
  • At request of Adam Shelton, retain sub-events selected for download of RaceRoster race. When mapping
    registration system to RunScore fields, if user selects “Cancel” or “Ignore all remaining fields”, nothing
    happened. Fixed. This was tough since it is done in recursive code processJsonTree and processJsonValue.
  • Also RaceRoster teams and team types are now included as part of participant downloads
  • Also sorting of search fields now sorts blanks to the bottom of the column
  • Minor UI Update to normalize the height of the search field in the Browse window
  • Fixed a minor issue with some runs not being visible on the TFRRS website
  • General coding improvements
RSServer/RSClient Version Level 2019.08.07
  • This release makes some changes to improve the usability of BugSplat.
  • It also resolves legacy warnings for a few external libraries.
  • It also resolves a few client issues that were reported through the crash reporting tool.
  • It also includes a check to ensure that a race has been opened before displaying the online menu.
  • It also includes a check to the sort algorithm to handle equality between generated floating-point numbers.
  • It also includes early work on functional testing
  • There was an issue with the close all windows functionality that caused the race to be closed as well.
  • It has been updated to allow for all the windows to be closed while keeping the race open.
RSServer/RSClient Version Level 2019.07.15
  • Jenna Ginsberg reported unexpected behavior when she had a long, complicated E2D on autorun. We
    modified the behavior of BugSplat to suppress Hang Detection.
RSServer/RSClient Version Level 2019.07.09
  • 2019-07-02: We implemented BugSplat crash reporting and hang-detection to
    RunScore Server and Client.  Future crash reports can be optionally sent by the user to help the team better
    diagnose and fix issues.
  • Some users reported that RunScore crashed when a download was attempted with a results screen open. Fixed.
  • Some users reported that a crash happened when obtaining reads from ChronoTrack Live Fusion. Fixed
RSServer/RSClient Version Level 2019.06.03
  • 2019-05-30: Some users found they had to login again when uploading results. Fixed.
  • 2019-05-27: Jenna Ginsberg requested that upon import, if a
    CSV file has a null header, that the corresponding data be ignored. Done. Steven
     feels this will be a big help for him so that he can delete any headers of data he does not
    want to import.
  • 2019-05-27: John Kinnicutt requested that Auto Refresh, while editing results,
    be turned off. Done. This keeps incoming results from messing you up while editing.
  • 2019-05-27: Mark Iverson requested that RunScore support RunSignUp
    egistrations in a “Super Event”. When a person registers for a super event, that person is
    automatically registered for all sub-events. For example, a race might have a 5K and a 10K and wants to have a
    registration class called, say, BOTH that allows a participant to register for both at the same time. Done.
  • 2019-04-25: Christian Lizier requested that a “Delete” key be added to
    the Announce keyboard where runners can type in their bib number and see and/or print out their
    results. Too often the runner makes an error but there was no backup/delete key. There is now. Christian also
    pointed out that there was no way to close the Announce screen without reverting to the physical keyboard. There
    is now a “Close” key.
  • 2019-04-25: To upload external/custom results to ChronoTrack LiveRunSignUp,
    or Race Roster, you do a right-click and send the results to the online site. Several timers
    have requested this be extended so that the right-click is not needed. In that way, the listing could be run
    automatically at a set time interval. This is done by adding the command: “External Report to” followed by the
    system: ChronoTrack LiveRunSignUp, or Race Roster.
  • 2019-02-20: At request of Jenna Ginsberg, have added time filtering to
    the Event to Database commands Laps Completed and Distance
    . This is helpful when, say, timing a race where the race director wants to know how many
    laps a competitor did each hour.
  • 2018-07-05: At request of Clifford Bruce, a number of improvements were made
    to the Team Relay command including a new command, Team Laps to Rounds.
  • 2018-05-23: Improved error messages. You’ll really like this change. Steve
     was watching someone scoring a race with RunScore when an error popped up saying there was a
    problem in one of the listing files. However, the message didn’t give the file name and line number so Steve fixed
    it. You now get both pieces of information. It didn’t work for “.include” files so Alan extended
    Steve’s work for that case.
  • 2018-04-29: Downloads contain an “Extended Verification Signed Certificate” registered
    to the Publisher “RunTime Software, LLC. (In April 2019, this was changed to “Fast
    North Corp”
    when RunScore was sold to Race Roster.)
  • 2018-04-19: Marek Blažek, Czech Republic, requested a command “LE Number of Laps” to include
    all runners regardless of how many laps they have run but, in addition, eliminate laps over the specified
    number. This helps solve the problem of runners who have finished the specified number of laps but are hanging
    around the finish mats.
RSServer/RSClient Version Level 2018.04.04
  • Following request by Zack Loggins, add support for downloading Corporate Teams
    from RunSignUp.
  • At the request of Jenna Ginsberg, added two new commands to listings: Add and
    Sub (or Subtract). They do the same as the @Add and @Sub
    commands in “Enter/Edit Results” but can be done in a listing. Add adds a given time to all
    times in the event and Sub or Subtract subtracts a given time.
  • Also, at the request of Jenna Ginsberg, we have provided a way to handle multi-day events by
    adding 24 hours to a chip/tag time for each day after the date specified in entries.ini. This
    is optional. You select it from the External Timer Initialization screen. At present it is only
    implemented for the RunScore Open interface but could be added for other systems when the day
    is not specified in the passing information.
  • Steven Keith aka “Kei”, working with Jeannette MacDonald, discovered that
    RunScore Results had a problem. If you uploaded awards and asked for a certain number in each
    category, all finishers in that category were in the report instead of just the number requested. Fixed.
  • Tom Plummer found that the control “GE Number of Laps” for a lap race was not working properly.
    Was showing results for participants that had not finished the specified number of laps. Fixed.
  • Tony Newton asked for a time format to handle multi-day events. New format is: “DD-HH:MM:SS”
  • Jenna Ginsberg requested that time-filtering as specified in each event’s definition be used
    with: Merge Events and Import of bibs and times. Done.
  • Christian Lizier asked for Multiply and Multiply By to work
    for times. Done.
  • We have documented a method to convert an individual database to a team database. We have also added two new
    sample races as illustration: TriTestIndividuals and TriTestTeams. This method
    uses Import Replace.
RSServer/RSClient Version Level 2018.02.07
  • It was reported by Steve Gajerski and Steven Finkelstein that Versions
    and later could not be installed on a Windows XP system. Fixed.
  • Found Import Replace was replacing the entire record. It should leave unaffected records alone.
  • Art Stockman found Laps Left field overlapping another field in Announce.
    Also, the field was using the default color instead of the specified color. Fixed.
  • Jenna Ginsberg requested that time filtering be done when doing a “Laps to Rounds” operation.
    That is, if time limits are set for the various rounds, those limits will be honored when moving the times from
    a lap-event to a round event.
  • Sylvan Smyth reported that the change for control characters in Version caused some
    Thai characters to be eliminated. Also Camilo Serrano Idrovo reported that the Spanish
    character Ñ was being eliminated. Fixed.
 RSServer/RSClient Version Level 2017.11.16
  • The pop-up has been removed from the “Assign Numbers” command. If you like the pop-up, a new command, “Suppress
    pop-up” was implemented so the user has control over whether the pop-up appears or not.
  • Robert Youngs, Super Race Systems,  requested that control characters such as new-line be
    removed from imported CSV file. He had the case of a race director who sent him files with the new line
    character embedded within a field. All control characters are now excluded during an import.
  • At Steven Keith’s suggestion several  fixes to the handling of the registration_ids in race.ini
    were made.
  • If a participant changes their event on RunSignUp, an incremental download will put them in the right event on
    RunScore. When RunSignUp changes a participant’s event, it creates a new entry and marks the old one as deleted.
    When RunScore does an incremental download it first checks for deleted participants and then downloads any
  • Steve Delahunty, RunTime Software, made a change to RunScore so that a listing file which is on
    auto-run, blinks to alert you to its status.
  • Rob Crawford, Sportstats, suggested an enhancement to the pre-event feature. This is to prevent
    participants who have finished their race from recording at later locations/points. For example, say a parent
    finishes their run and their time comes into an event called FINISH. Then they go to watch their kid run whose
    event is KIDS5K. If they get close to the kids’ finish line, they might record some passings. To prevent this,
    you designate FINISH to be a pre-event for KIDS5K and, in addition, check the [new] checkbox: Discard times that
    are later than the pre-event time.
  • Kyle Dunnack, The Last Mile Racing, asked us how to time a lap race where the first lap is
    shorter than the rest. We told him RunScore couldn’t handle it. This wasn’t a good enough answer for Steve
    Steve dove in and made changes to the RunScore code to allow you to enter two distances
    in the Lap Distance command. If there are two distances provided, the first one is the distance for the first
    lap and the second the distance for all subsequent laps. This is implemented for general reports — not for the
    Announce feature.
  • Steve Delahunty made a change to avoid problems when using RunScore in Dropbox. Problem
    reported by Bill Teschek.
  • At the request of Jenna Ginsburg, added a control, “No SMS Warning” to entries.ini. This will
    prevent a pop-up if there is an SMS problem. You would want to use this control if you are sending out SMS
    messages automatically and don’t want the process interrupted.
  • Josh Gerber requested that RunScore support file-load of race|result
    files. Done. You use Tools/Chip options to tell RunScore if the file contains bib-tags or chip-tags.
  • At the suggestion of Jon Krupa, you can chain the pre events. For example, say you set the
    START event as the pre event for the SWIM-IN event, the SWIM-IN event as the pre event for BIKE-OUT, and the
    BIKE-OUT as the pre-event for RUN-OUT. Then if a person has an early detection on the RUN-OUT mat, RunScore will
    check the BIKE-OUT for a time. If it finds one and that time is less than the RUN-OUT time it is rejected. If
    there is no RUN-OUT time, e.g. if the person missed the RUN-OUT mat, RunScore will see if the RUN-OUT event has
    a pre event. It does, so it will check there and so on.
  • Greg McCormick requested that he be able to change an entrant’s event in RunScore and have it
    reflected to that entry at the RunSignUp database. This is implemented so that all you have to do is right-click
    on the “event name” field and select, from the menu, “Change event”. You’ll be presented with a list of the
    events so you can pick the new one.
  • Eric Kramer requested that downloads from RunSignUp support corral assignments. Done.
  • At the request of several users, have made changes to RSClient so that:
    1. If RSServer is not up, you now get a beep and it keeps trying. The status line at the
      bottom of the screen informs the user that RSClient is still trying to connect.
    2. If RSServer and RSClient are connected and RSServer
      is taken down or crashes, the user will hear a beep. The status line, after a few seconds, will display
      an “Attempt to connect” message. It will keep trying until RSServer comes up again. Note, this even
      works so that if, when RSServer comes back up, it is working on a different race.
  • At request of Steve Stone add counties in a RunSignUp download. This feature was added so that
    a number of “include” RunSignUp commands could be used in addition to counties: template_participant, corrals,
    est_finish, corp_teams, registration_addons, coupon_details, registration_notes, checkin_data, waiver_info,
RSServer/RSClient Version Level 2017.04.25
  • Steve Delahunty and Bill Rosen pointed out that if you select a results screen
    from the menu and that screen is already open, nothing happens. Now the one you selected comes to the
  • Steve and Bill also pointed out that if you have file open for editing and you
    open the same one, you will now have two instances of that file. Fixed so that now if you try to open an
    already-open file, that file will pop to the foreground.
  • Steven Keith reported that if you open results files using Alt-N more than once. Each screen
    will be a bit wider than the last one. Fixed.
  • Added new command “List DNF” at suggestion of Tony Newton. When used, if a participant does not
    finish a leg of a race, the letters “DNF” are inserted in the time place instead of leaving the time blank,
    which is the default.
  • Jenna Ginsberg reported that if an Auto Run/FTP session is running and the Internet connection
    is lost. Error messages pop-up. If they are not cleared, eventually RunScore must be restarted to continue the
    upload of files. Fixed by not doing a pop-up message. Instead the error message is displayed on the Listing
    Window status line and a beep is issued.
  • Dennis Joffe wanted to include information about whether an entrant was in the club of the
    sponsoring organization. It turns out that RunScore was properly processing membership information for USATF
    membership and USAT membership but not for the generic club. This is now handled by putting the membership_id
    (club id) in a RunScore field. Once there, you can use a [control] section in entries.ini to, say, put the club
    name in a field or, say, put an X in a field indicating the participant is a club member.
RSServer/RSClient Version Level 2016.11.28
  • Made an improvement in Announce so that now you can use the Announce Event feature from
    RSServer. This allows you to send e-mail results to a finisher shortly after the finisher crosses the finish
  • Bob Bickel, Founder of RunSignUp, offered that we could send E-mail under his
    contract with SendGrid.  RunSignUp’s contract allows for very large numbers of e-mails, Bob
    said we could operate under their license for free. SendGrid is different from the other e-mail systems which
    RunScore supports because it is done through a web API (Application Programming Interface) rather than directly
    to e-mail. We have found it to be very fast and reliable. To use SendGrid, contact us at to get a userid and password that will give
    you access to SendGrid.
  • It has always been required that when doing Team Mixed scoring that you need to set the number of displacers
    equal to the number of finishers. If you didn’t, the results could be weird. This is now enforced. If you don’t
    have them the same, you will get a pop-up saying they are not the same and they will be forced to be the same.
  • Working with Selwyn Blake, have made a lot of improvements to the Announce feature. You can now
    display, in addition to the Division (e.g.DIV or SEX) Place, Division total which shows the total number of
    finishers, who have finished thus far in the specified division.
  • At request of Enrique Belchi Ruis, we have added a new command Pack Time to
    assign the time of the leader of a pack to all riders in the pack in a cycling race.
  • The new command Pack Time can also be used in an Event to Database listing to
    insert the Pack Time to a field.
RSServer/RSClient Version Level 2016.04.26
  • When clicking on a search field in Browse, that field will appear at the bottom as the field to search on.
  • Improvements to incremental uploads to RunSignUp, ChronoTrack Live, or Race Roster via right-click on listings
  • Add “Auto Run” feature from right-click on a listing file. This is much more powerful than the old auto run from
    inside a listing file since you can multiple listing files doing auto run at the same time.
  • RunScore can produce JSON formatted reports which can then be dynamically uploaded to a web site.
  • Upgraded to latest version of Help and Manual, the program we use to generate the Help screens. The only think
    you will notice is a nice looking header at the top of each topic.
  • And, as usual, some bugs were fixed.
RSServer/RSClient Version Level 2016.01.23
  • Steve Stone pointed out that if he assigned bibs in RunScore, the changed records did not get
    flagged as changed so did not get uploaded to RunSignUp. Fixed.
  • Changed upload block size for RTRT uploads from 2000 to 500 to make the uploads more reliable.
  • When opening a file from within RunScore, the file types *.lst, *.rsm, *.txt are provided. Have added *.ini.
  • Updated the Sample races with new field “Name” which is the concatenation of “First Name” and “Last Name”. Makes
    listing simpler and allows uploading of “Name” to results as one field.
  • Natalie Young pointed out that if she created a race series in RunSignUp that started in 2015
    and finished in 2016, only the 2015 events could be downloaded. Fixed.
  • Have made an improvement that users have been asking for to the RunScore Results incremental upload capability.
    Before you could only designate one file to do incremental uploads as the race is going. Now you can have
    multiple files active.
  • Jon Krupa requested the ability to name the splits in a TFRRS race. Done. Just use the “Field
    Header” command to name the split.
  • added to list of supported registrations sites
  • Jenna Ginsberg requested the ability to concatenate two fields together and put them in a third
    field but without a space between them. This can now be done by putting “Space (tab) 0” before the “Selected
    Value” commands.
RSServer/RSClient Version Level 2015.09.02
  • At request of Jon Krupa, sort meets by date when selecting a TFRRS meet. Also,
    allow selection of “All meets” or “Future meets.”
  • Both Sid Steinweg and Brian Sparacino reported that they couldn’t send a
    TFRRS-XC report to the editor. Turns out that neither had obtained a login/password yet from
    DirectAthletics. However, you should be able to produce the report without having a signon.
  • We are encouraging users to update to this version since improvements have been made to the RunSignUp
    integration with RunScore Results as well as other fixes and improvements.
  • Download of registrations from imATHLETE is now officially supported. An earlier beta version
    only allowed a download blocksize of 50. Due to a change at imATHLETE, that is now 1000. We would like some
    feedback from RunScore/imATHLETE users.
  • Have included the TFRRSRace in the update download. The NCAA is working with
    DirectAthletics and have developed this required format for all college cross-county meets
    starting this fall. It will probably also be used for many high school race. We are looking for testers.
  • Active Works no longer requires a timer to contact their Active representative for an app
    token. The new procedure is: “For a Timer to view an Event’s data, an Event Organizer must ‘invite’ them. When
    individuals accept an invitation to be a Timer in the system, ActiveWorks Endurance now automatically checks if
    they have an API token. If not, the system will automatically email the token to them. Additionally, Event
    Owners and Timers can email themselves an API token by clicking Get Timing API Token on the event
  • Uploading RunScore Results to RunSignUp uses the reg_id.txt file in the race folder to store the registration_id
    values. A registration_id field is not needed. If it IS used, the results were getting the registration_id from
    the reg_id.txt file which could cause a problem if the id is in the field and not the file. Made a change so
    that RunScore now checks for the registration_id in both locations.
  • Mark Toretsky and Steven Keith reported that a race simulation caused the
    first person in the race to be a non-runner, that is, someone without a bib number. The problem was introduced
    in 2014 when the simulation was changed so to not include the unregistered runner number. Fixed.
  • Bill Teschek reported that the upload of changed records to ChronoTrack Live uploaded the same
    records each time. Fixed. Note: if fields such as the age-division field, often called DIV, changes, that does
    not result in that record uploading. The record is only flagged as changed if the field changed is one of those
    fields that are to be uploaded. To find out which fields they are, look in the CTLive_fields_mapping.ini file in
    the RunScore folder. The same is true when uploading changed records to RunSignUp.
  • At request of Doug Liverside, extend the number of parameters from 20 to 36 (1 -10, ‘a’ – ‘z’).
    Had been implemented only as far as ‘j’.
  • Added two features to Announce for use with lap races, requested by Andrés Alañón Vázquez: “lap
    distance field” for keeping the lap distance in a field. This is for races where everyone is not running the
    same distance. Likewise, added “laps left field” to specify the number of laps and to tell Announce to display
    the number of laps left when everyone is not running the same number of laps.
RSServer/RSClient Version Level 2015.04.28

This version is a merge of RunScore Results, Version and
RunScore Version to create RunScore Version

What does this mean? It means that from now on, whenever you use RunScore to interact with the RunSignUp site,
you will be using the RunScore Results. Also, uploading and downloading registrations at both RunSignUp and
ChronoTrack Live have gotten easier. We eliminated “Sync with server” and replaced it with a very easy way to
download changes from the system and upload changes made in RunScore to the system.

The RSRServer and RSRClient (RunScore Results server and client) have been retired. The new modules have the
same name as the old ones. If you think you may want to go back to Version, save it. Or you can do a
complete download using RunScoreSetup.exe to revert to

View the short video on the main RunScore page: which
highlights features of this new integration. Also on the main page is a document showing how to allow each runner to
see themselves crossing the finish line on a YouTube video.

  • You no longer need to have a field “registration_id” in your database. The registration_id information is kept
    in a separate file (race.ini) in the race folder.
  • Also in the race.ini file are time stamps for each record that has been changed. This is used for upload of
    changed records.
  • “Sync with server” has been removed due to problems. In its place you can do an “Incremental download” to get
    changed online records. Likewise, you can upload new and changed RunScore records with one click. This works for
    both ChronoTrack Live and RunSignUp.
  • You can take advantage of these features without making changes to your normal RunScore setup.
  • Results are extremely easy to post. You merely right click on a listing button and instead of sending to a
    printer or the editor, you send it online. Handles overall results, award listing, and team results. With one
    more click you can view the results online.
  • Set up for e-mail and text notifications. Once set, a runner or his friends can go to the RunSignUp site and ask
    for e-mail and/or text messages for selected runners.
  • Provide links for each finisher to the specific person in a YouTube video showing that person
    finishing. This is all done from RunScore.
  • You can download from RunSignUp to get the participants or, if you have another way to obtain participants you
    can put them in RunScore and with one click upload them to RunSignUp.
  • Not using the RunSignUp site for registrations for this race? You can still take advantage of the above
    features. There is a nominal cost for posting results. There is also a cost for text messages. If you ARE using
    RunSignUp for registrations, these services are free.


  • At request of Troy Rebert, added External/Custom Report capability to Team
  • At request of Fred Dunn and Les Morelles, made Division Place
    and Division Total headers in a “RunScore Results” of “ChronoTrack
    Live External”
    posting more meaningful. For example, for sex place and sex total they would now
    read “Sex place” and “Sex Total”.
  • The headers of reports are always produced in proper case (e.g. “Name” instead of “NAME”). Sid
    asked for a way to control the the capitalization of headers. This can be done with the new
    command: “Header case (tab) None”. The default is “Head case (tab) proper”. “Upper” and “Lower” are not
    supported but could be if the need arose.
  • The “RunScore Open Interface” for external bib/tag systems, has been extended so RunScore knows
    if the data being set is chip data or bib data. You use “RSBI” for a bib-tag and “RSCI” for a chip-tag. These
    improvements came about from working with Thorsten Voegel, Race Result, Germany.
  • Fixed a bug that kept the registration_ids from getting uploaded to RunSignUp or RunScore Results.
  • Changed the simulate feature so you will no longer get the “Unregistered Runner Number” in the results produced
    by simulate.
  • Doug Cleavenger reported that Importing a CSV file that had CR/LFs within a field caused a
    problem. This problem had been fixed some time ago for internal imports such as downloads from a registration
    system. It is now fixed for imports from File/Import.
  • The logos on the main page of RSServer and RSClient have been changed to
    reflect the fact that RunScore Results is part of the module. They now read, respectively:
  •    RunScore           RunScore
    Results/RSServer     Results/RSClient
  • When uploading a large custom/external result set, the upload is now done in pieces of 1000 results per piece.
  • New command “Output Format” allows you to create the output in any of the following formats: Text (default),
    XML, JSON, or HTML.
  • The new entries.ini command “Modified Field” now works from RSClient. It previously only worked from RSServer.
  • If you change a RunSignUp entrant to a different event online, a new registration_id is assigned. On the next
    incremental download, RunScore will notice that it is a new registration_id. It will then look for the bib
    number. If the bib number in the new record also exists in the RunScore database, the new record will replace
    the old but preserve fields that are not in the download.
  • “Sync with server” function has been removed because it has not been robust. It is replaced with the, already
    existing, “Incremental download” in conjunction with the new “Upload modified registrations”.
  • New command: “Team Total” can be used in an Event to Database to send the team total for each individual’s team
    to a field. It can also be used in an overall listing to produce, next to the “Team place” column a “Team Score”
    column which shows the team score for each individual’s team.
  • Improvements have been made to the criteria which determine if a field has changed. This is useful when
    uploading changed registrations.
  • Can now handle USAT (USA Triathlon) and USATF (USA Track and Field) membership
    numbers when downloaded from RunSignUp.
  • Doug Liversidge pointed out that the “Divide” and “Divide By” commands did not work for time
    fields. Fixed.
  • Preliminary support has been added for the DirectAthletics
    TFRRS-XC site. This will be final once more testing is done.
    The support allows timers to upload collegiate cross-country results to the DirectAthletics site.
RSServer/RSClient Version Level 2015.03.31
  • At the request of Jenna Ginsberg, have extended the Total (to a field) command to handle times.
    The receiving field must be flagged as a time field.
  • At request of Steven Keith, have added a new control “Contains” which tests if a field contains
    a given string of characters.
RSServer/RSClient Version Level 2015.02.23
  • (Real-Time Runner Tracking) integrated
    with RunScore.
  • Added a new control to entries.ini. “Modified field” which timestamps each entry when it is
  • Added RaceEntry, ActiveWorks, SignMeUp, and
    registration systems supported.
  • Can combine First Name and Last Name into a third field, say, “Name” using commands in entries.ini.
RSServer/RSClient Version Level 2014.07.14
  • Add support for registration site Eventbrite.
  • Can download by Event (RunSignUp) or by Race (ChronoTrack Live) or by Activity (ZapEvent).
  • Made a lot of enhancements to the Announce feature.
RSServer/RSClient Version Level 2014.03.01
  • When downloading from RunSignUp or ChronoTrack Live, people have complained that if they do a download on top of
    a older download, any new data such as bib numbers are wiped out. This is changed now so that if a downloaded
    field is blank, it will not write into the equivalent field in RunScore.
  • Andrés Alañón Vázquez reported that European style dates (dd/mm/yyyy) were not being handled
    properly in export and import. Fixed.
  • You can now select on a date field as if it is in YYYYMMDD format even though it might be in MMDDYY format. For
    example, a select on the field asking for all entrants who have a date-of-birth later than 1990, you would have
    a select with the condition: “GT (tab) 1990”.
  • At request of Andrés Alañón Vázquez, add a prefix capability to SMS messaging. Often the mobile
    phone number is the base number but, particularly in countries outside of the US and Canada, a ‘+” plus a
    country code must prefix the number. To implement this feature, add a new field in your RunScore database
    called, say, “Mobile prefix”. Then in entries.ini tell RunScore the name of this field using the new SMS Prefix
    Field command, e.g.
SMS Prefix field (tab) Mobile prefix
  • The method for selecting which online systems RunScore is connecting to has been changed to make things easier
    to use. Now, you first go to Tools/Online System to select the system (Active, ChronoTrack
    Live, RaceIt, RunSignUp, RTRT, Texting, XACT, ZapEvent). You can go to Online where, instead of seeing submenus
    for each system, you will have only the submenu for the online system you selected. This helps avoid the problem
    some are having of clicking on the wrong system.
  • RunSignUp support now includes a menu check item to put an “External Report” online. An “External Report” is a
    normal RunScore report that is rendered in JSON which RunSignUp transforms into online results.
  • The documentation in Help for uploading RunScore Results has been completely rewritten with many examples.
  • At request of Jenna Ginsberg add to Export of times:
    1. Control of time format
    2. Pace and Rate
    3. Field Header for Pace and Rate
  • Also at request of Jenna, add to Live Results
    1. Column headers for Rate and Pace
  • At request of Robert Youngs, make “Field Header” command work in Live Results so that you can
    put your own column heading on each column.
  • With help from Brian Sparacino, RunScore supports SMS (cell phone texting) provider: Twilio. They offer inexpensive texting in the U.S. and a number of other
  • Made improvements to File/Import to handle dates. If the field is designated as a “Date” field,
    the date format specified in entries.ini will be used. This wasn’t previously the case.
  • Major change in Announce feature to include colored fields. Encouraged by Andrés Alañón
    from Spain.
  • Have removed “Number of chip fields” from Preferences. You should set this in entries.ini so
    that it applies just to one race.
  • Added Pace and Rate to Live Results at request of Jenna Ginsberg.
  • At request of Debbie Burke, add “Sort bibs” (Alt+B) command to results. She said this will help
    in finding duplicates and also help in lap races. It’s pretty slick. You can Alt+B to sort by bibs and then
    Alt+T to sort by time and be right back to where you were.
  • Fixed some problems between RSServer and RSClient when the versions don’t match. It used to give a pop-up error
    on RSServer but this bound things up at the client until the server responded. Now, if there is a warning (the
    versions only match for the first two number) you can proceed. If there is an error (the version only match for
    the first number), you cannot proceed. In both cases, RSServer is none the wiser but the person on RSClient will
    receive the proper warning or error.
  • John Burke, requested an improvement to Live Results to handle triathlons. Done. You can see an
    example here.
  • Released a document on how to integrate RunSignUp and RunScore. Click here. IntegrationOfRunScoreAndRunSignUp.pdf
  • Finally implemented a suggestion of Steven Keith: That is, to enhance the
    Export command to include times. You include a time just like you do in a report. You can use
    the Minus command to compute net or gun times. You can also use the Pace
    command but not the Division Place. This change makes things much simpler. In many cases, if
    you use this new feature you will not need to use the Event to Database operation.
  • At request of Pedro Zapata Padilla, change the import of ASCII times so that if there is a
    duplicate bib and the time is faster than the earlier one, the faster time is used.
  • Steven Keith found that the responses to custom questions were not being downloaded from
    RunSignUp. A change was made by the RunSignUp developers and a change was made in RunScore so this now works.
RSServer/RSClient Version Level 2013.11.12
  • Latest stable version.
  • After many requests, Live Results can now handle different size fonts.
  • Have removed support for uploading results because this is no longer supported by
  • Jon Krupa asked for controls for using RunScore with two monitors. The problem was if you last
    used RunScore on one monitor and then removed that monitor, you could no longer access RunScore because it
    thought it was being displayed on the ghost monitor. Fixed.
  • Made a change to Ipico support. Their new controller adds a few comment lines to the exported file. These lines
    start with the ‘~’ character. RunScore now removes lines that start with ‘~’. Problem identified by Kip
  • Had a request by Carl Magnuson to allow the selection of “Bib ID” or “Chip ID” to be made in
    Entries.ini in addition to being able to make it from the Tools/Chip options menu. This has been implemented as
    “Bib or Chip”. Example:

Bib or Chip          Bib
Bib or Chip          Chip
  • Implement the new NCAA cross-country tie-breaker rule: “Ties in team scoring shall be broken by comparing the
    place finish of the five scoring members of the tied teams. The team with the majority of winning places shall
    be awarded the higher place.” Thanks to Pat Leone for telling us about the new rule. To use the NCAA rule, add
    the line: “Team Tie Breaker (tab) NCAA”.
  • At request of Jenna Ginsberg, have added “Multiply” command to work just like the SUM command
    but instead of adding together the contents of several fields, it multiplies them. Can also multiply by a
    constant number with the “Multiply By” command.
  • At request of Carl Magnuson, have extended the concept of multiple chip fields for systems that
    use bib tags. That is, if you set the number of chip fields (in Preferences or in entries.ini), to, say, 2, then
    if RunScore cannot find the bib tag in the bib field, it checks the next search field. But there are two cases.
    If in Tools/Chip options you set for Bib Tag, it starts looking in the bib field. If, on the other hand, you set
    for ChipTag, then the search begins in the first search field after the bib field.
  • At request of Denika Voget, add new Time Format: 0H:MM:SS.01 that produces times with two hour
    digits. For example: 00:01:23.45, 01:23:45.67, 12:34:56.78.
  • Made a change so that the “Please Wait” dialog box does not appear anymore when uploading just one entry whether
    by a listing file or by the “Sync with server” technique.
  • Jon Krupa asked that when doing Event to Database with a time into a right-justified field, if
    the field is shorter than the data, truncate to the left rather than to the right as is normally done. Done.
  • Brian Sparacino told us about the NK Interval Timing Watch and loaned us one so we could
    support it. It’s very inexpensive but it does not transfer times live. Instead, after the race is done the times
    from multiple events (or segments as they call them) can be transferred to RunScore. The transfer takes about 30
    seconds whether there is one time or a few thousand. Not only did Brian Sparrcino tell us about
    the NK Interval watch, he provided a computer program which allowed me to support it.
  • Add support for registration site ZapEvent. There are now so many online
    systems supported that they have all been moved from the Tools menu item to their own menu item “Online.”
  • Not a change but information: Within two days, two different people could not print to their label printer. We
    forgot to tell you in the Help section on label printers that you MUST turn off “Printer Dialog Box” in
  • Matthew Studholme suggested changing the pop-up you get when a new manually-entered time is
    less than the previous one. Previously, the only response was “OK” and the time was retained. He suggested a
    different pop-up with “OK” and “Cancel”. If “Cancel” is clicked, then the new time is discarded. Done. This
    makes handling typing errors easier.
  • Carl Magnuson pointed out that when you try to clear a protected field for all entries, the
    field to be cleared, marked in red, becomes the bib number field. If you’re not careful, you could clear out all
    your bib numbers. This has been fixed. You can now clear a protected field.
  • Jenna Ginsberg requested that the laps event be sorted by time before executing the
    Laps-to-Rounds command. This is necessary since sometimes times from chips do not come into the event in order.
RSServer/RSClient Version Level 2013.05.03.
  • A new menu item: Field-Column mapping has been added so that you can create the mapping from ChronoTrack Live
    columns to RunScore field names. This is handy if you have no registrations at ChronoTrack live but want to
    upload registrations from RunScore.
  • Can now upload an awards list to RunSignUp (and soon to ChronoTrack Live).
    That is, your usual awards file, with very slight modifications, can be shown online.
  • Jenna Ginsberg requested a new command “Multiply By” for use with Event to Database so that a
    time can be multiplied to compensate for events that take less time when adding up times from a multi-event
    race. Done.
  • Can do team scoring with different numbers on each team by setting Team Score to zero. Suggested by Jay from
  • Improved field mapping with ChronoTrack Live custom fields. Instead of the field names such as
    “custom_elevent12345”, RunScore translates them into the description of the custom question.
  • Made improvement to ChronoTrack Live upload. You still need an external_id field but you don’t have to have
    anything in the field. If you don’t RunScore will assign a number one higher than the highest external_id. This
    works both for uploads from a listing file and while in “Sync with server” mode.
  • Added a touch screen keypad to the Announcer screen so partipants can enter their bib number on the screen
    keypad to see their results. Of course, your computer screen must be a touch screen to use.
  • With RaceIt, RunSignUp, and ChronoTrack Live, a new menu
    selection that tells you which event or race you are working on.
  • Team Relay wasn’t working unless it included a penalty event. Works now even without one.
RSServer/RSClient Version Level 2012.12.02.
  • In a first for RunScore, YouTube videos have been added to the Help screens. These first two
    are in the RunSignUp section showing how to download registrations, upload registrations,
    upload results, upload live results, and setup and upload splits.
  • At request of Steven Keith, reload entries.ini when executing the “Update all entries” command. The entries.ini
    is reloaded whenever RunScore detects that a change has been made but if there is a change in one of the
    included files, RunScore will not about that. This change forces the re-loading of the file.
  • At request of James Oaks, allow use of “Field Length” command when printing labels to prevent
    long names from spilling over.
  • RunScore support for RunSignUp now handles live update. That means that it uploads just those
    finishers who have finished since the last upload. This all happens automatically. RunScore checks every 10
    seconds to see if there are new finishers. If there are, it uploads them.
  • At request of Andre Yelle, Race Headquarters, added two new Announce commands. One controls the
    length of time an announce screen is up before it refreshes for the next finisher. The other allows you to see,
    instead of the next finisher after such a delay, to see the most recent finisher. The commands are “Announce
    Update Sec” and “Announce Use Last”.
  • At request of Robert Youngs, Super Race Systems, add command “Conditional
    headers”. When this command is used, a header in an awards list is skipped if there are no finishers in that
    category. Usually it is best to have the headers displayed so that people know that there is such a category and
    it had no finishers. However, you might want to use the command in a race that has a very large number of
    categories, many of which have no finishers.
  • Support for RunSignUp for: (1) Download of registrations, (2) upload of
    registrations and correcting of registrations on RunScore and having them appear right away on the RunSignUp
    site, and (3) Upload of results. Once uploaded, you can click on a link in Tools on RunScore and see the results
    on the site.
RSServer/RSClient Version Level 2012.07.19
  • Bill Teschek wants to separate the columns, for readability, in a triathlon results report. To
    do this he inserted the ‘|’ character between columns. When this is done, the headers are adjusted to remain
    over the proper columns but the ======= underlines do not. Fixed.
  • At request of Jenna Ginsberg and Steven Keith, RunScore now pops up a message
    when you connect to a device that requires event mapping. You are shown the present mapping and asked if you
    want to use it. If you answer “no” the file events_mapping.ini will be erased and you will be prompted for each
    external location whose name is not the same as one of your RunScore events.
  • Because of a problem that Alan Higley had with e-mail when an email field had junk but not a
    valid e-mail address, we have added the command “Contains.” With this one can check that the field contains the
    @ character.
  • Several people have been pointing out problems with Live Results running on RSClient. Have made
    some major changes that should help in making Live Results more robust. Give us some feedback if you uncover any
RSServer/RSClient Version Level 2012.04.27
  • At request of John Resman, eliminated leading blanks upon import of *.csv files. If the field
    is right-justified, the blanks will be restored during the import. Also eliminated leading blanks upon export to
    *.csv files.
  • Barbara Hindenach requested a change in how the bib number is handled when using
    auto-increment. If you enter a new person and hit F10 or F12 to save, the next bib number pops up, say 456. If
    you start typing in the next person and notice on the drop-down that that person is already in your database,
    you can select that person. When you did that, the bib number field was cleared. Also, if you put in the number
    you want to add and then start typing a new person, the same thing happened. What Barbara requested and what now
    works is that the bib number is retained. One reason I was motivated to make this change is that the previous
    behavior was bothering me, too, but I guess I needed a push to get around to making the change. Thanks to Steven
    Keith for testing this new feature.
  • Josh Drew reported that the Look Up Replace command no longer worked. Fixed
    for use in a listing and in the INI file.
  • Have added SMS/Text messaging through an SMS provider. See Help file for details. We are working with UpcellText but are interested in working with other SMS providers. We were
    put in contact with UpcellText by RunScore customer Jim Young.
  • New feature added: Team Relay.
  • Added new ActiveCF.xml to RunScoreUpdate.exe. If you are having a problem connecting to through
    RunScore, be sure to make sure you have the current version of this file. The way to tell is by looking at this
    line: <IP></IP>. It must have that ‘xes’ in
  • John Snitko was having problems with extensive use of Event to Database. Made some changes to
    try to protect the database when writing when more than one thread at a time tries to write.
RSServer/RSClient Version Level 2012.01.16
  • The Select Event command to select participants out based on their time in an event has been improved. You can
    now select based on a comparison of times between two events. For example, say you wanted to find problems such
    as a runner who crossed a split after crossing the finish line. You could write:

    Select Event (tab) SPLIT1
    GE (tab) FINISH
  • Debbie Burke requested that the Points Table be allowed to have non-integer values, e.g. 10.5.
    Done. To make places to the right of the decimal appear in output or in Event to Database, you must use the
    Precision command which tells RunScore how many places to the right of the decimal point you want to use.
  • You can now download registrations directly from online registration site This is accomplished through an API (Application Programming
    Interface) provided by RaceIt.
  • At the urging of Jeff Castro, got “Instant Print” working from RSClient. This has never worked since the
    creation of the client/server version of RunScore.
  • At request of Ron Larson and Steven Keith, add system variable %ISO
    which produces time in a format without colons, e.g. “150105” (for 03:01:05pm). They wanted this
    so they could produce file names based on time. The system variable %time% produces times such
    as “15:01:05”.
RSServer/RSClient Version Level 2011.07.21
  • Add check for duplicate names to Design Screen
  • Switched from InstallShield to Inno Setup for creating distribution files. Updates for both RSServer and
    RSClient are in the single file RunScoreUpdate.exe.
Version Level 2011.07.02 RunScore client/Server
  • May have eliminated the “Must run as administrator” problem when installing RunScoreSetup.exe. The problem was
    ambiguous wording in the InstallShield documentation.
  • At suggestion of Jon Krupa, test to make sure there are not duplicate field names in the
  • With help from Steven Keith, improved the Help screens concerning transponder races.
  • At request of Andrés Alañón Vázquez make place and division place work for lap races with a
    scratch time in the Announce screen.
  • Can now use a scratch event subtracted from a laps event in a listing file. Before you could subtract a fixed
    time (gun time) but not a different time for each competitor. (You have always been able to subtract the initial
    time [“lap 1”] from the other laps using the “Net time” feature.) This improvement was inspired by the work for
    Andrés Alañón Vázquez (Version that allowed this in a “Merge Events” listing.
  • J-Chip records are very similar to ChampionChip records so it is hard for
    RunScore to tell which system is in use when loading files. There is no problem when the data come through
    TCP/IP since the user selects the system. In order that RunScore knows that the files being read in are J-chip
    files, a new control (J-Chip file loading) is added under Tools/Chip Options.
    Note: There is no problem with J-Chip records being read as ChampionChip records unless it is a
    race where the clock goes past midnight. J-Chip has taken over the ChampionChip “antenna” field and replaced it
    with a “day” field which keeps track of how many days you are into a race.
  • Working with George Groome and Mark Hendley, made a fix to the External Timer
    Keyboard” device and made a change to the “Barcode” device so that it works
    with a keypad that terminates a line with either <LF> or <CR>. Also set the default for the barcode
    to be bib mode instead of time mode.
  • At request of George Groome, reinstitute “not found added” for an individual event. But,
    instead of using a checkbox on the Edit Event dialog box, it is set in the entries.ini file. This allows you to
    turn on “not found bib number added to database” for an individual event. However, this is just for external
    timers such as the Time Machine. This has no bearing on chip/tag races since at the time a chip/tag record since
    the particular event is not known at the point a chip/tag record is being parsed. See “not found” in Help for
  • New command, Select Event, allows you to select on an event. Previously, you could only select
    on a field.This allows filtering. For example, you could select out only those who started after the gun. It is
    hoped that you clever users will find new and exciting things to do with this new command.
  • Added support for MyLaps ProChip although this was just the addition of the name to Initialize
    External Timers since it already worked by selecting ChampionChip when using the MyLaps Toolkit.
  • In the past few days had two instances of team results reporting a team full of blanks ahead of the first place
    team. In both cases, it was an event with a start event and, due to errors or people crossing mats, there were
    negative times. Made changes to catch errors like this.
  • At request of Douglas Kirk, allow Message command in team results and, in
    particular, allow an initial message that will display at beginning of line.
RSServer/RSClient Version Level 2011.04.07
  • Latest stable release.
  • A new file, Boston.2013.tac, with qualifying times for the 2013 Boston
    has been added to the Common folder. You should use this for marathons run after September
  • New command Continue used with Selected to allow you to mark a field and do another function,
    such as send an e-mail in one *.lst file.
  • New command EMAIL PORT;
  • At request of Steve Moland, “Announcers on the Run,” when doing an Import
    and you run into a field not recognized, in addition to Ignore and Cancel,
    have added “Ignore all remaining fields” button. When it is pressed, no more fields are
    processed and the file being imported is read but only up to the field being queried.
  • Can now use Gmail, AOL and other SMTP servers for e-mail.
  • Some people did not like being warned every time they went to delete a bib or time in
    . This can now be set in Preferences.
  • At request of Marek BLAŽEK, made a change to the sort routine to handle diacritic symbols
  • Marek BLAŽEK requested that “Time difference” and “Total Time
    be added to allowed features of “Event to Database.” Done.
  • Debbie Burke did not like the “I-beam” cursor on the main page which changed to a “pointer”
    cursor on the links. Was hard to see. Changed to “pointer” for bulk of screen and to “hand” on link. This is the
    more standard way to handle the cursor.
  • It was pointed out that when tabbing across the Initial External Timers dialog box, that is was not possible to
    reach the TCP checkbox. It was only possible to get there with the mouse. Fixed.
  • When using a device via TCP, baud does not matter. In order to reinforce that, when you check the TCP checkbox,
    the Baud drop-down disappears.
  • Some people like to be in “insert” when editing and some but some like to be in “replace.” At request of
    Steve Scheidt, allow the editor to start in either “insert” or “replace” mode. Whatever mode
    you have it in when you leave the editor, it will be in that mode the next time you edit a file — even if you
    have closed RunScore in the interim.
  • At request of Paul Williams, add alternate white and gray background lines on Instant
    to improve readability.
Version Level 2011.01.12 RunScore client/Server
  • At request of Steven Keith, add new system variable %race path%. This can be
    used in the System Command to copy files from the race directory.
  • At request of Steven Keith, provide a way to execute a listing (*.lst) file on startup of a
    race. This is done by adding a parameter in the Properties/Target section of the RSServer or RSClient icon. The
    parameter is /startup=filename. In the example below, RSServer starts up the sample race and
    then starts the announcer.

c:\runscore\rsserver.exe sampleraces\sample\entries /startup=announce.lst


c:\runscore\client\rsclient.exe /startup=announce.lst

  • You can also specify the IP Address and the port on the command line of RSClient. The parameters are /address=ipaddress
    and /port=number. For example:

c:\runscore\client\rsclient.exe /startup=announce.lst /address=MyDesktop /port=33000

  • While we were at it, we decided to allow you to set the Login name for RSClient to log into RSServer. If you are
    not using login names, don’t worry about this feature. You can only use this feature if you are requiring a
    login name but not requiring a password. The parameter is /login=login_name. For example:

c:\runscore\client\rsclient.exe /startup=announce.lst /address=MyDesktop /port=33000 /login=Announcer

  • At request of Craig Wilson, allow team members beyond the number scoring to advance. This is
    controlled by setting a negative number for Advance Maximum control
  • You have always been able to specify a “scratch” event in RunScore by making the event name start with the
    letters “STA” or “SCR”. Now there is a third way. Just specify the event to be a “Start” event in “Misc/Edit
    list of events”. When a scratch event’s time is subtracted from another event’s time and there is not time for
    the scratch time, a time of zero is used. On the other hand, if it is not a scratch event, for example it might
    be the BIKE event in a triathlon, then when the BIKE time is subtracted from the next split and there is no BIKE
    time, the resulting split is a blank. That allows you to easily find someone who missed a split point.
  • New team feature: Team Spread: Prints out, when using Team Format Columns, the spread in time
    between the first finisher and last scoring finisher on each team.
  • New team command: Team Format Brief: Implemented at request of Pat Leone. With
    Team Format Brief, only the team place, team name, and team score are printed.
  • At Steven Keith’s request, add “Starts with” (or “SW”) command to entries.ini.
    It had been added to *.lst processing some months ago.
  • Fixed a problem in entries.ini where you needed to put in dummy data in the [data] area even if none was
Version Level 2010.11.19 RunScore client/Server
  • At request of Jon Krupa, discard any line of an import file that will produce a record in which
    all fields are blank. This helps to eliminate those blank records in an Excel file that gets incorporated into a
    *.csv file.
  • Have you ever been working with results in a chip/tag race and were in “bibs and times” (F5) mode and pressed F2
    to delete only to realize that you pressed F3 (numbers mode) by mistake and the next F2 ends up deleting a bib
    but not the time thus mis-aligning the bibs and times? Have you ever hit F2 by mistake and seen a finisher
    disappear? Some months ago a command “Edit Results (tab) BOTH” as suggested by Mike Richards was added so that
    you would always be in F5 mode. However, the user could, with a click of the mouse or by depressing F3, put the
    mode back to the Bibs mode. After many discussions with Steven Keith, Mike Proctor, and
    Jon Krupa
    , two significant changes have been made to help. Keep reading.
  • At request of Jon Krupa and Mike Proctor, provide a way to “lock” the Results
    screen in a “both” mode — bibs and times. This can be done using a new control in Preferences. The setting can
    be overridden for a race by setting “Edit Results” in entries.ini. It can be set to “bibs”, “times”, or “both”.
    Likewise, if you only want the “both” mode for a few races, you can use the “Edit Results” to use the “both”
    mode for those races and leave the “both” mode unchecked in Preferences.
  • At request of several users, provide protection for deleting bibs and times. It works just like the delete
    function in Browse. That is, when you first go to delete a finisher or a finisher’s time, you will be asked if
    you really want to. You will also be told that you can “arm” the deletion by using Ctrl-F2.
  • Steve Moland, of Announcers on the Run, requested a change to the Announce
    screen. He asked that a blank line be inserted if the user pressed enter with no bib number. This allows him to
    put in blank line if he makes an error — increasing readability.
  • Made improvements in the Initialize External Timers dialog box. Prevents you from having two
    devices connected to the same port. (This is allowed when RSServer is the client and is talking to chip
    controllers which are servers since the servers have different IP addresses.) Changes also allow you to stop a
    device while keeping others running. Now if you don’t change anything for a device (timer, port, baud, tcp), the
    device will not be stopped and started again. This is particularly useful when using the Summit timer.
  • If you have a device activated through Initialize External Timers, you can turn it off by
    blanking the port number or by setting the Start/Stop drop down to Stop.
  • It now tests if you are using the same port for two different devices but allows in the case of systems such as
    IPICO in which case it checks to see if the IP Addresses are the same.
  • Jason Biggs found that AccuChip data was not being handled correctly when coming through
    TCP/IP. Fixed.
  • Tony Newton asked for a change to the Live Results screen so that the most recent finisher
    stayed at the bottom of the screen and is highlighted in blue. To do this, set the Scroll Speed
    to zero and the Scroll Delay to, say, 1 second.
  • Working with Ron Larson, found that sometimes in an Event to Database
    operation, data is written that is longer than the field. RunScore was not protecting for this situation which,
    sometimes, caused crashes. This could be a very significant fix.
Version Level 2010.09.12 RunScore client/Server
  • Added support for Japanese language
  • Fixed Chatsworth support.
  • You can now set the lap difference in a lap race in Entries.ini. If two times, in a lap race are within the
    time, in seconds, the second time is eliminated. Command: “Lap Difference”. The default is 10
Version Level 2010.06.27 RunScore client/Server
  • Jenna Ginsburg found that a Time Format of NONE was not
    working with the Announcer feature on RSClient. Fixed.
  • Cleaned up and fixed some problems in the sample races. Made them available for download independent of the full
    install (RunScoreSetup.exe).
  • At urging of Steven Keith, add red background text UNREGISTERED RUNNER NUMBER
    to Unregistered Runner Number (entry record 0) so that people realize that they are not editing an entry.
Version Level 2010.06.23 RunScore client/Server
  • The old *.tac files have been replaced with new ones based on the age-grade tables. These files
    are used to flag times that the USATF considers quality performances based on gender, age, and time. You can
    tell if you are using the new ones because they have a 2010 date.
  • Unregistered Runner Number (URN) is now protected and is always in record number zero.
  • You can now check for Updates via the Click for Updates link
    on the main page.
  • Add support for TCP/IP link between timing systems and RunScore. This allows you to have your
    timing system farther away.
  • And, as usual, a number of bug fixes which are documented in the LatestRevisions.html file.
  • The logo in Live Results can now be a *.png file (Portable Network Graphics) or a *.bmp
    (Windows bitmap) file
    . Previously, RunScore only supported bitmaps.
Version Level 2010.03.21 RunScore client/Server
  • Made an improvement to the edit box when you edit a bib or a time (Right-click on a bib or time). Before the
    edit box had a thick border which had the effect (in Win XP) to hide the lower part of the characters being
  • Fred Dewsberry found that Look Up stopped working on the server once the RSClient is started.
    This has been a long-standing bug. Not sure why it took this long for someone to report it. Fixed.
  • Sylvan Symth requested that when there are no finishers for a team score, that, instead of
    displaying an annoying error pop-up, just produce a page with no results — only the header. Done.
  • John Lauces reported that bar codes were not printing correctly. The problem was introduced
    when the default monospaced font was added to Preferences. Fixed.
  • Greg McFerren found that the BEST command was not working correctly. It was finding the worst
    performances instead of the best Fixed.
Version Level 2010.02.20 RunScore client/Server
  • More bug fixes as described in the LatestRevisions.html file.
Version Level 2010.01.11 RunScore client/Server
  • This version mainly fixes bugs that have been found in Version There have been some additional
  • At request of Andrés Alanon Vazquez, add two new commands for use with the Announce screen: “Last Lap Time” and “Average Lap Time.”
  • Included a tip in the Help screens by Steven Keith about providing RSServer and a race folder on a thumb drive so that the race management people can do their own data entry without actually installing RunScore.
Version Level 2010.01.03 RunScore client/Server
  • This is the first version of RunScore produced with Microsoft Visual Studio VC++ tools built on
    top of OWLNEXT which is an independent development based on Borland OWL (Object Windows
    . Almost all development before this point was produced with Borland tools.
  • NOTE: This version of RunScore will not run on older Windows operating systems: Windows 95, Windows 98,
    Windows ME, or Windows NT. It will run on Windows 2000, Windows XP, Vista, and Windows 7.
  • What are the advantages?
    • The largest advantage from the user’s point of view is that we have squashed the bug that produced those
      “Busy clipboard” pop-ups. The bug was traced to some Borland code. I reported this to
      the OWLNEXT developers who have fixed it.
    • There are no functional advantages and no perceived speed differences.
    • There are no longer DLLs that get installed in the Windows directory. Therefore, if you want to move
      RunScore from one computer to another, all you have to do is copy the RunScore folder to a thumb drive
      and then copy it into the new computer. For those technically inclined, this type of application is
      called a “static” application instead of the RSS/RSC which was a “dynamic” application since it depended
      on external DLL files. Note, however, that there are still some DLLs installed with RunScore (Summit
      timer DLL and DLL) but since they are in the RunScore directory, they will be copied to the
      new computer.
    • When I retire from supporting RunScore, it will be far easier to turn the development package over to
      another person since it will be using modern tools.
    • The Microsoft Visual Studio Interactive Development Environment (IDE) is far superior to the Borland
      IDE. It should be since it has had an additional 13 years of improvements. This helps me in development
      and in finding bugs. It is also much more fussy, warning me of possible problems.
    • For those Vista users that were having problems with the special functions of printers in Vista, like
      Back to Front printing, the VC version incorporates the new Printer Dialog box that works perfectly
      under Vista. Probably does the same under Windows 7.
  • What are the disadvantages?
    • While the install package will be about the same size, updates will be larger since they are static
      applications. But in this day of high-speed access, I don’t see this as a problem.
  • Recent changes
    • At the suggestion of Steven Keith, add support for monospace fonts other than “Courier
      New.” In Preferences you can specify what default monospace font you want. It will be used in all
      listings. These fonts make for much better looking listings. In Help/Index/Preferences are examples
      showing the difference between an Arial monospaced font and the Courier New font.
    • Another new control in Preferences allows you to specify if you want the page number at the top or the
      bottom of each page of the printout.
    • Jeff Glaze pointed out that a person with a birthdate of 01/01/2000 did not have their
      age updated. Fixed.
    • Version control. As before, for RSClient to connect to RSServer, the first three
      numbers in the version must agree. For example RSClient Version can connect to
      RSServer Version Before, if the first three did not agree, it was not possible
      to connect. Now that is only true if only the first two numbers agree. If the first two agree but the
      third does not, you can connect but you are given a warning. Things will probably work but there may be
      some functions that do not agree.
    • A RunScore API (Application Programming Interface) has been developed. It can be fetched at The
      purpose of the API is to allow programmers to access the RunScore database and results. This could be
      used to add entrants, to develop new results listings, or many other uses. It is only useful for
      programmers who can program in C++.
    • At request of Art Stockman, make change to allow changing of event in Initialize
      External Timer so that data can be directed to a different event without having to shut RunScore down.
Version Level 2009.12.06 RunScore client/Server
  • Last Version of RunScore produced with Borland tools
  • Implement Time Format for Live Results at request of Steve Gajerski.
  • At request of Bill Teschek, add commands for entries.ini to type-ahead. A few were missing.
Version Level 2009.11.25, RunScore Client/Server
  • Latest stable release.
  • Made a change so that if there is a entries.val file and no entries.val.xml, the entries.val is always converted
    to entries.val.xml.
  • Working with Pat Riley, a method has been developed for sending text messages. See
    Appendix/Text Message.
  • John Luaces and Fred Dewsberry reported a crash when connecting the RSClient
    to the RSServer. Found that this happens if a Look Up command is in the old entries.val file. The Look UP
    command should be removed from entries.val and put in entries.ini. A change has been made so that this no longer
    causes a problem.
Version Level 2009.11.25, RunScore Client/Server
  • Latest stable release. I had thought Version was okay but it had some problems. This one has been more
    thoroughly tested.
  • Craig Chiger found a problem with Look Up in RSServer Version
Version Level 2009.11.20, RunScore Client/Server
  • Have changed the operation of Look Up in a *.lst file as requested by Steven Keith. If it calls
    for Look Upand a similar Look Up was not specified in entries.ini, RunScore creates a new Look Does, does the
    look up on the entire database, and then discards it. The reason for this is that the older method required you
    to start and stop RunScore do to the look up to add in a bunch of late registrations. You would not want to do
    this during a race.
  • Add a new command “Look up Replace” which works just like the Look Up command except it replaces all matching
    fields. The Look Up command does not replace, say, a city name if there is already data in the field. This
    feature is handy if you have a chip/tag race and have a large number of missing finishers. If you have a
    database for these extra runners, the Look Up Replace command can automatically put them in at the proper place
    in the database.
  • At request of Tony Newton and Steven Keith, have added a new command: Update
    All Entries
    . This is somewhat similar to the Alt-F4 to update but is much faster since it doesn’t
    involve all the checking of fields. The main purpose is to process the commands in your entries.ini after making
    a change.
  • With the advent of more and more Chip/Tag systems and the use of multiple split points on races, the old way of
    handling the Swap of bib numbers between two people became a problem.  With one or two events, it was easy to
    use the old “@Swap n1 n2” that swapped the bib numbers in two finish positions in the event.  But, with multiple
    split events or triathlons, this had to be repeated across all events to work.  It also was overwritten when
    your refreshed or re-downloaded the finish times and bib numbers.
    To correct this, you can now swap the information assigned to bib numbers in the Database, just like the
    athletes did in real life, when they swapped bib numbers.  When you open the Browse screen and type in:  “@Swap
    bib#1 bib#2”,  RunScore will swap the data assigned for those two bib numbers, so that all the events will now
    have the correct info listed for the bib numbers and finish positions.  Now the bib numbers match the person who
    actually wore them.
  • Add support for RFID chip system via TCP/IP. RFID had been supported earlier but only by loading files produced
    by the RFID system.
  • Becky Mestas requested for a larger number of names be allowed in the drop-down-search box in
    Enter Names. She had a large database with more Smiths than could be displayed. Done.
  • Working with Steven Keith, define a new type of event called a “Spill” event. You can put this
    beyond the last event for which you have rounds/passes specified to catch extra passes. For example, say you
    want Round 1 to go into Run and Round 2 to go into Bike. If a person crosses the mats extra times, these times
    would go ino the spill event.
  • The Live Results now runs in full-screen mode.
  • A number of improvements have been made to the Announcer Screen. It now displays in full-screen mode so you no
    longer see the Windows menu bar. This is particularly nice when used on a large screen or with a projector.
  • Working with Andrés Alanon Vazquez, Marek Blazek, and
    John Snitko, have added ability for Announce screen to have headers across the top. This only makes sense for monospaced fonts like Courier New and when using the “No Squeeze” option with Announce.
  • In addition to the “automatic headers,” you can create your own using the Header/.end of header commands on the Announcer screen.
  • The type-ahead in the RunScore Editor is now optional because of a request by Tony
    and Steven Keith. You can deselect it in Preferences. The command drop-down is
  • Implemented type-ahead and command drop-down on RSClient. Previously it only worked on RSServer.
Version Level 2009.10.07, RunScore Client/Server
  • Mike Proctor said he often types in a new name and, by mistake, presses F3 (search) instead of
    F4 (update). RunScore then asks if the user wants to do a new search or not. Either reply erases what was just
    entered. Mike asked for a third option, Cancel, that will retain what was just typed. Done.
  • Fixed crash problem with Announce reported by Pat Leone and Jeff Castro.
  • Josh Gerber reported that Alt-F4 (update all entries) caused a crash. It turned out that all
    his bib numbers were blank. Fixed.
  • Pat Leone reported that the Announce command by itself, that is without an event or header
    specified, was sending output to the printer instead of to the screen. Fixed.
  • Jenna Ginsburg and Jeff Castro reported a problem with auto-run causing a crash. Jeff provided a race folder that allowed us to find and fix the problem.
  • Fixed a problem, reported by Wally Marantette, that caused a “Duplicate Finishers” listing to
  • Andrés Alanon Vazquez discovered that Division Place in the Announce screen no longer worked. Fixed. Also made a change so that you can display the place and a division place referring to the same event.
  • Added command type-ahead and drop-down to the RunScore editor. This allows you to see the commands that start with the letters that you type. You can then pick the one you want using the cursor keys or the mouse. Or you can continue typing until what you have typed has only one corresponding command. At that point the rest of the command will be filled in.
  • Have added a test to make sure that RSClient and RSServer are at the same level. The first three numbers in the Version must be the same.
  • Debbie Burke pointed out a problem with the Unregistered Runner Number (URN). If you don’t have a URN defined in either Preferences or in your entries.ini file, then it should work as before. That is, the first entry in your database becomes the URN. A change has been made to make this work like it used to.
  • Have added three commands to entries.ini: Not found added, Show additional, and Show select event.
  • At request of Andrés Alanon Vazquez add gun-time support for J-chip. If a gun-time arrives, it is placed in the file Guntime.ini.
  • Working with Denika Voget found that there are problems if you set the number of chip fields to zero. Fixed so that this can’t happen anymore.
  • After many requests, the “Message” command has been added to the Announcer screen.
  • Steven Keith made a great suggestion with respect to the Announcer screen. He suggested it be tied to an event using a new command Announce Event. In this way, whenever a new finisher is recorded into that event, the finisher’s name and other information will automatically be displayed on the screen. This makes it much easier to set up and gives more flexibility. For example, you no longer need to have the screen fed by chips. For example, you could tie it into the select event which is fed from the keyboard of an external timer.
  • Steven Keith pointed out that the /*** … ***/ form of comment was not supported in entries.ini. Fixed.
  • Add new command Average which is used in conjunction with the Sum command. When used it computes the average of the fields instead of the sum of the fields. Works for integers, floating point numbers, and times. Suggested by Steven Keith.
  • Again at request of Steven Keith, add Starts with (or SW) command. You can use this in a conjunction with “Select” to select out all entries that start with the specified characters.
  • At suggestion of George Groome, make the external editor field in Preferences scrollable so you
    can enter a longer path name.
  • Also, made some corrections to the help files with respect to the fact that you can use an external editor to
    receive RunScore output.
  • Fixed a problem pointed out by Andrés Alanon Vazquez that the effect of a language change did not show up until you processed “To editor” (F7).
  • Jenna Ginsburg asked for a Footer to be able to handle the centering of a line as is done in Headers. Done.
  • Jenna pointed out that times past 24 hours were not working on RSClient for Winning Time active chips. Fixed.
  • Added support for new feature in ChronoTrack’s SimpleClient that allows for data stream to be restarted if the TCP connection breaks. With this feature, the data doesn’t have to start from the beginning.
  • Add location-to-event mapping for J-chip at request of Marek Blazek.
  • Fixed an alignment problem with lap event output.
  • Made another fix to the browser output at request of Jenna Gingburg.
  • At request of Steven Keith, provide a way to cancel out of a @ listing that has multiple
    duplicate finisher problems.
Version Level 2009.07.20, RunScore Client/Server
  • At request of Tony Norton, we have made the “Listings beep” optional. He found it annoying,
    especially when running an auto-run listing. Others, such as Steven Keith, like the beep. It gives some
    assurance that RunScore is responding. The default is to have the beep off. It can be turned on from
  • At request of Kevin Jackson, add a check for non-unique bib numbers when you “Update All”
    (Alt-F4). This can also be done be creating a “Remove Duplicates” listing which checks for
    duplicate bib numbers. Be sure to check only those bib numbers that are not blank.
  • Kevin Jackson also requested an “undelete” for the Entries screen. This has been implemented by
    the normal Windows “undelete” command Ctrl-Z. It just restores the most recently deleted record. (Note: if you
    want to undelete a change in a results file, use F9 to reload the bibs and times.)
  • Working with Jenna Ginsberg and Denika Voget, add support for Winning Time
    Active chip system via TCP/IP.
  • At request of Richard Rosant and Stephen Keith allow MINUS or
    PLUS commands to subtract or add a fixed time to an event before merging it using the “Merge
    ” command.
  • At request of Jon Krupa, add “Move Up” and “Move Down” to the
    editing of your list of events (under Misc.). Makes it much easier than the Cut and Paste
    method although the Cut and Paste are left there for large moves.
  • When the “Progress” pop-up was removed some time ago, the progress messages were sent to the status line.
    However, due to priorities, they were not showing up until the processing was done. Therefore, these messages
    have been moved to the “comment” line on the Listings screen. Also, will also hear a beep when you process a
    listing file to give you audible feedback that a file is being processed processing.
  • In addition, if you update all your records on the Enter/Edit screen with Alt-F4, the progress is shown on the
    “records” line.
  • Josh Merlis suggested use of /* to begin several lines of comments and */ to exit comment mode.
    This is the same as is used in many programming languages. Done.
  • At request of Steven Keith, added a feature to the import of bibs into results. If a bib is not
    found, you can specify whether you want to handle all unknown bibs the same way: (1) assign Unregistered Runner
    Number, (2) add to the database or (3) ignore. Or, you can continue to handle them one at a time as in the past.
  • Jon Krupa asked for RunScore to continue importing times and bib numbers even if a line has
    only a a time or a bib number instead of both. Done.
Version Level 2009.05.29, RunScore Client/Server
  • If data in an entries.ini file is longer than the intended field, it could cause a problem. Fixed.
  • Made some progress in fixing the “busy clipboard problem.” In doing this we had to make some changes to the
    RunScore editor. Now the blue, vertical line does not appear when you first open a file but as you work on it,
    the blue line will appear. Steven Keith was key to this improvement. He was able to find cases
    that failed fairly often.
  • At request of Marek Blazek from the Czech Republic, changed import of database to allow other
    than comma as the delimiter. When RunScore discovers that a file does not have a comma in the header, it
    requests the user to enter what delimiter the file uses. If the delimiter is the tab character, you enter the
    word “tab”. If you import from a listing file, you can set the “Import delimiter” according to the type of file.
  • Have stopped shipping the special version of Notepad.exe. It was causing some problems. Instead you can now use
    the normal Windows Notepad or use another editor. To use another editor, set its location in Preferences. If you
    don’t specify another editor, the Windows Notepad will be used by default.
  • Often a data entry person types over the Unregistered Runner entry, often called the “bandit” entry. This can
    cause lots of problems. There are now protections. If you DO want to change the entry, you will be warned
    (twice) about what you are about to do. This feature was requested by Steven Keith.
  • At request of Bill Teschek add command “Laps to Rounds.” This moves multiple finishes by a
    runner in a LAPS event into subsequent events based on which lap has been completed. This is done automatically
    in a chip race but this command is to fix problems such as a runner not crossing a mat on a given lap. The time
    can be inserted and the Laps to Rounds command run to reassign the various laps,
  • Marek Blazek from the Czech Republic requested that the Event to Database PLACE command work
    for lap races. The place is computed by determining the order by laps finished and for those with the same
    number of laps, based on time. Done.
  • Fixed a problem with auto-alignment pointed out by Mike Moore. When inserting bandits, the last
    bib was turned into a bandit instead of moving down one slot.
  • At request of Andrés Alanon Vazquez made a change to Announce so that if Net Time is specified, the number of laps displayed is one less to account for the initial passing. Also, the time is computed by subtracting each runner’s initial passing from the most recent one.
  • Made a change to HTML output so that the results are as they were with RSW if the CSS file runscore.css is not found. In addition, you can now have a “local” *.css file in a race directory called entries.css.
  • Brad Pickle pointed out that you could no longer close an external timer without leaving RunScore. Fixed.
Version Level 2009.04.05, RunScore client/Server
  • At suggestion of Tony Newton, made the use of CSSs (Cascading Style Sheets) for web output more
    flexible. Before there was just one CSS which was called runscore.css. Now you have a different one in a race
    folder called entries.css. RunScore looks for the *.css in the race folder first and, if not
    found, uses the global one in the RunScore directory.
  • The following changes were suggested by Steven Keith. He also did extensive testing that the
    changes worked and that the changes were backward compatible with earlier versions and with RSW.
  • The entries.val validation file, has been replaced with a new XML file called entries.val.xml.
    The transition is painless. When you next make a change in Design Screen or change properties in the
    Enter/Edit Names screen for a field, the new file will be generated automatically for you .
  • Have you wanted to change a field parameter, such as changing from no case to proper case or add another
    value for “Allowed” in middle of typing but did not want to go to Design Screen and
    have to restart the race? You can now change most parameters on the fly. Just right-click on the field
    as you always did. When you click on Okay, the new entries.val.xml file will be
  • Changed the way the Look Up command is defined. Instead of putting it in the entries.val file,
    it is now placed in entries.ini. This is a more logical place. To aid in the
    transition, for now, you can have it either place.
  • For people who create this new XML in a folder and use the “Look Up” command in the
    INI, you will get an error message about “Look Up” in the INI when you run this race on an earlier
    RSServer/RSClient version or RSW.  Just acknowledge the error message and the VAL file will load the
    Look Up for you the old way.
  • Remove the “Edit Validation file as text” from the Misc menu.
  • Jon Krupa mentioned that if you have no listing (*.lst) files, you get a pop-up that could be
    annoying. A change was made to put an appropriate message on the comment line.
  • Andrés Alanon Vazquez, requested a way to show Division Finish order on the Announce screen. This was done by supporting the Division Place command.
  • At request of John Snikto, added a “Laps left” to the Announce screen for use in laps races. This allows runners to see how many laps remain.
  • Working with Andrés Alanon Vazquez, made a number of improvements to the Announce screen. He wants to use it on a large screen just past the mats of a lap race so the runners can see their bib number, place, number of laps run, and the total distance covered.
  • Working with John Snitko, developed a way for chip/tag systems which do not have a
    round/pass/lap capability to handle rounds. It works by creating a lap event followed by events with rounds
    specified. The data goes into the lap event and also into the appropriate round event. This only works on
    RSServer, not on RSClient.
  • Made some improvements to chip/tag processing of round events.
  • Andrés Alanon Vazquez, who lives in Spain, requested that the Announcer screen be enhanced to handle lap races. It now can show place, time, number of laps completed, and distance covered.
  • Another improvement was made to Announcer so that the screen can be used just beyond the finish line in addition to being ahead of the finish line. When used beyond the finish line with a chip/tag system, a runner can see her results as soon as she crosses the finish line if a large monitor or data projector is used.
  • At request of Marc Roy and Tony Newton, add ability to keep FTP open so files
    can be uploaded periodically. The file will typically be rewritten through an auto-run process. New commands are
    FTP loop” and “FTP Close“. The loop specifies how often, in seconds, the
    upload should happen.
  • Create a file called guntime.ini for ChampionChip which is created when a
    ST00007 chip ID is received. This had already been implemented for ChronoTrack.
  • Add “View Guntime.ini” to Misc menu so you can pop-up the guntime file
  • RunScore now supports English, French, Spanish, and Portuguese.
    The “French” item on Preferences has been removed and the user’s language preference as set in the Windows
    Control Panel is used to select the language. The only place the language matters is in some of the listings
    such as “Number of records” at the bottom of a listing and words such as “Place”, “Rank.”
Version Level 2009.01.08, RunScore client/Server
  • Discovered that comma-delimited-files included in entries.ini were not working. Only space-delimited and
    tab-delimited were working. Don’t know when this broke since the comma-feature was added in April 2007. Fixed.
  • Fixed a problem found by Art Stockman.He found that when using Event to
    and the PACE command, the resulting pace had a nonsense number instead of a
    zero if using the MINUS command and there was no scratch time to subtract off.
  • Added more documentation on ChronoTrack with help from Steven Keith.
  • Add more documentation on Ipico with help from Josh Drew.
  • Add support for ChipTiming from Brazil (
  • At request of Greg McFerren, add information in dialog box when starting up TCP/IP connection
    with Ipico.
  • Liz Steinweg suggested a change in the Enter/Edit screen from “Not found. Search
    pop-up to “Not found. New Search?” This is so that, after an unsuccessful
    search, you have the option to keep the cursor in the field so you can compose a new search or, if you answer
    “No”, you can go back to the bib number field. The old wording sounded like RunScore would search again for you.
Version Level 2008.12.05, RunScore client/Server
  • Can now sort labels by column as well as by row.
  • Handle ties in cross country races.
  • Fixed a problem when bringing in ChampionChip or ChronoTrack chips via TCP/IP. If the computer got very busy,
    some data could be lost.
Version Level 2008.10.21, RunScore client/Server
  • Add browser scroll capability to RunScore output.
  • Steven Keith suggested a new command @time which been added which allows you
    to set times in the Results screen.
  • New command Advance Export App will cause the advancer information to be appended to a
    previously exported file.
  • At request of Pat Leone, add Team Score Export command for cross country races
    so you can produce a format for uploading to a web page.
Version Level 2008.09.16, RunScore client/Server
  • An Events file editor has been added to RSServer.
  • A number of users, including ones very familiar with RunScore, have told me that they have often forgotten to
    sort results. Therefore, RunScore has been changed to always sort the results unless you use the new command:
    NO SORT.
Version Level 2008.07.28, RunScore client/Server
  • At request of Bill Teschek and encouragement from Bob Teschek and Steven
    there is now a way to do team scoring based on Age and Gender grading. This is invoked with the
    new command Team Score Agegrade.
Version 7.0 Level 2008.06.21, RunScore client/Server
  • After 13 months of development and five months of testing by many users, the RunScore Client/Server package is
  • The older RSW.exe will be retained but changes will not be made. All users are encouraged to move to RSServer
    even if they do not plan to do networking.
Version 5.0 circa 2000, RunScore for Windows
  • First version of RunScore Windows. It allowed earlier race setups to work under Windows.
October 2001: RunScore reviewed in Road Race Management.
  • The review compared RunScore and The Race Director. It concluded that RunScore
    was harder to learn but that one could go much farther with RunScore.
Version ?? circa 1997
  • Supported ChampionChip
  • Decided to stop calling the program “Running Score II” and call it “RunScore” since that is what most customers
    were calling it. Easier to say, right?
Version ?? circa 1992
  • Add “passing of parameters” (RunScore macros in @ files) feature which allowed much more flexible programming.
    This was instituted to handle the Adirondack Canoe Classic which had a huge number of classes.
August 1986: RunScore demonstrated at Road Runners Club of America meeting in Portland, ME
  • This meeting is what really launched RunScore. We scored their 5 km race on Sunday morning using a push-button
    attached to the serial port and a bar code scanner attached to the keyboard with my son, Clain, doing the
    scanning and Wayne Nichol (of course measurement fame) pushed the timing button at the same time he was the
    announcer for the race.
Version 1.0 1985, RunScore for DOS
  • First compiled version of RunScore DOS, call Running Score II. The reason for the II is that an earlier program,
    written in BASIC, was called Running Score.