Free purposes of research software for linux

POPsearch is a personal search engine that is designed to help you easily organize and find information on your computer. POPsearch lets you index your entire collection of email messages and files. This collection can then be searched remotely from any computer that has a web browser.
POPsearch has features thatre especially appealing to the programming community because it actively allows you to expose and classify data relationships.
Think of POPsearch as a new type of Relationship Engine for your daily flow of information.
With POPsearch, you can easily index your entire collection of email messages and files. This collection can then be searched from any type of web browser.
When POPsearch is configured correctly, you can also access your POPsearch data remotely from any computer that has a web browser.
POPsearch currently supports the following types of data:
- Ascii text
- FrameMaker documents
- LaTeX documents
- Microsoft DBX mailboxes
- Microsoft MBX mailboxes
- Microsoft PST mailboxes
- Microsoft Excel spreadsheets
- Microsoft Word documents
- PDF documents
- Postscript documents
- RTF documents
- Troff files
- WordPerfect documents
When the indexing is finished, the data is available for analysis with any web browser or in a batch mode from the command line.
The following features are available when POPsearch interacts with a web browser:
- If your computer maintains a connection to the Internet, you can access your POPsearch data remotely from any computer that has a web browser.
- The user can navigate through the entire collection of files and email.
- Popular sources of information are displayed as the user navigates through the data.
- References from/to files are expandable.
- The user can search the entire collection or specific directories.
- The user can also narrow the scope of the search to specific types of data or directories.
- The user can save searches, and mark the valuable items thatre contained in the search results.
- Search results can be expanded through the use of a thesaurus.
- Search results can also be expanded through the use of automatic spell checking.
- The system supports wild card searching (e.g. *string or string*).
- When viewing email topics, the user has the ability to "mine" the email for active and casual participants. For each participant, the user is able to determine the types of information that the user is most interested in.
- Email messages are automatically rated for positive or negative content.
- For every file and email message, the system displays a thumbnail representation of the data.
- The user is able to classify files, saved searches, email, and web sites into various personal research topics. The user also has the ability to search in their personal research.
- Comments can be attached to files and email messages.
- The user can apply personal ratings to files and email messages.
- A collection of themes allows the user to customize the look and feel of the POPsearch interface.
From the command line, POPsearch creates HTML output for CGI purposes, or XML output for other applications.
POPsearch is currently designed to run on *nix platforms.
POPsearch is licensed under the GNU General Public License, version 2.

Multi Purpose Scanner is a simple scanner written in C that starts a number of child processes, connects to a list of IP addresses, and logs a certain number of characters to standard out or a file.
Low band use is one consecuence of a single connection per child that recieve an only defined num of characters.
Main features:
- $ mpscan -e -p 25 -t 15 -r 100 -T 20 -R 192.168.1.0-10
- Fast mp-scan 0.04-testing ...
- Total ip: 11
- 11/11 91% 192.168.1.10
- Generated 11 ip in 0.199 seconds
- Ip range parsed... 11 ip found
- Scan on 25 started...
- 0:192.168.1.0 -> Network is unreachable
- 3:192.168.1.3 -> Connection refused
- 2:192.168.1.2 -> Connection refused
- 1: 192.168.1.1 -> 220 zeus.olimpo.hm ESMTP Postfix (Debian/GNU)
- 6:192.168.1.6 -> No route to host
- 5:192.168.1.5 -> connected but no data retrived within 7 sec
- 4:192.168.1.4 -> No route to host
- 8:192.168.1.8 -> connect timeout after 15
- 7:192.168.1.7 -> No route to host
- 9:192.168.1.9 -> No route to host
- 10:192.168.1.10 -> No route to host
- Waiting for child dead...
- Scanned 10 ip in 3.14821 seconds
- Scan ended... enjoy the result
Enhancements:
- added T and I option,
- added changelog,
- added debian rules,
- added man page,
- Makefile created.

Protothreads are extremely lightweight stackless threads designed for severely memory constrained systems, such as small embedded systems or wireless sensor network nodes.
Protothreads provide linear code execution for event-driven systems implemented in C. Protothreads project can be used with or without an underlying operating system.
Protothreads provide a blocking context on top of an event-driven system, without the overhead of per-thread stacks. The purpose of protothreads is to implement sequential flow of control without complex state machines or full multi-threading.
While protothreads originally were created for memory-constrained embedded systems, it has found many uses as a general purpose library too. Examples include multimedia streaming server software, grid computing research software, and MPEG decoding software for Internet TVs.
Main features:
Main features:
- Very small RAM overhead - only two bytes per protothread and no extra stacks
- Highly portable - the protothreads library is 100% pure C and no architecture specific assembly code
- Can be used with or without an OS
- Provides blocking wait without full multi-threading or stack-switching
- Freely available under a BSD-like open source license
Example applications:
- Memory constrained systems
- Event-driven protocol stacks
- Small embedded systems
- Sensor network nodes
- Portable C applications
Enhancements:
- PT_SCHEDULE() now returns true both when a protothread is waiting and when it has yielded.
- A README file has been added for Visual C++ users that explains how protothreads may trigger a compiler bug and how to prevent this from happening.

Avanor, the Land of Mystery is rapidly-growing Rogue-like game with an easy ADOM-like user interface. It has countryside and subterranean areas to explore, a quest system, and some original features.
Moving and locations
1 - south-west
2 - south
3 - south-east
4 - west
5 - current position
6 - east
7 - north-west
8 - north
9 - north-east
w + direction - walk in direction until something interesting is found
~ - rest a while (for debugging purposes only)
o - open a door
c - close a door
< - go up stairs
> - go down stairs
l - look at a location
Dealing with objects
e - equip an item
i - display your inventory
d - drop an item
, - pick up an item
E - eat an item of food
D - drink a potion
! - mix potions
r - read a book or scroll
s or _ - sacrifice an item
O - open a chest
g - give an item to somebody
u - use a tool
P - quick pay
Characteristics and skills
A - display your skill levels
a - use a skill
q - display the quests you have undertaken
@ - display your character details
W - display your weapon skills
x - display experience needed to gain next level
Combat and spellcasting
t - target an opponent
p - pray to the gods for aid
T - change your combat tactics
Z - cast a spell
^Z - repeat the last spell cast
# - display your elemental magic levels (not yet used)
Miscellaneous commands
U - use outer objects
R - show list of alchemy recipes
C - chat with somebody
S - save the game
Q - quit the game
M - display previously shown messages
0 - recenter the screen on the player
[ - make screenshot
? - display this manual
Enhancements:
- Fixed bug with traps
- Support for compilation with modern compilers
- FHS compatibility and Gentoo Linux ebuild

Open Journal Systems (OJS) is a journal management and publishing system that has been developed by the Public Knowledge Project through its federally funded efforts to expand and improve access to research.
Main features:
- OJS is installed locally and locally controlled.
- Editors configure requirements, sections, review process, etc.
- Online submission and management of all content.
- Subscription module with delayed open access options.
- Comprehensive indexing of content part of global system.
- Reading Tools for content, based on field and editors choice.
- Email notification and commenting ability for readers.
- Complete context-sensitive online Help support.
OJS assists with every stage of the refereed publishing process, from submissions through to online publication and indexing. Through its management systems, its finely grained indexing of research, and the context it provides for research, OJS seeks to improve both the scholarly and public quality of referred research.
OJS is open source software made freely available to journals worldwide for the purpose of making open access publishing a viable option for more journals, as open access can increase a journals readership as well as its contribution to the public good on a global scale (see PKP Publications).

AllPeers Beta allows you to organize and share your media files privately and securely.

AllPeers requires that you provide an email address for registration purposes which is stored on our central server.

For details about our privacy policy, please see http://www.allpeers.com/privacy.

Joeq is a virtual machine and compiler infrastructure designed to facilitate research in virtual machine technologies such as Just-In-Time and Ahead-Of-Time compilation, advanced garbage collection techniques, distributed computation, sophisticated scheduling algorithms, and advanced run time techniques.
Joeq is entirely implemented in Java, leading to reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed -- all dynamically.
Each component of the virtual machine is written to be independent with a general but well-defined interface, making it easy to experiment with new ideas.
Joeq is released as open source software, and is being used as a framework by researchers on five continents on topics ranging from automatic distributed virtual machines to whole-program pointer analysis.
Joeq is a virtual machine and compiler infrastructure designed to be a platform for research in compilation and virtual machine technologies. We had three main goals in designing the system. First and foremost, we wanted the system to be flexible. We are interested in a variety of compiler and virtual machine research topics, and we wanted a system that would not be specific to researching a particular area.
For example, we have interest in both static and dynamic compilation techniques, and in both type-safe and unsafe languages. We wanted a system that would be as open and general as possible, without sacrificing usability or performance.
Second, we wanted the system to be easy to experiment with. As its primary focus is research, it should be straightforward to prototype new ideas in the framework. With this in mind, we tried to make the system as modular as possible, so that each component is easily replaceable. Learning from our experience with Jalapeno, another virtual machine written in Java, we decided to implement the entire system in Java.
This makes it easy to quickly implement and prototype new ideas, and features like garbage collection and exception tracebacks ease debugging and improve productivity. Java, being a dynamic language, is also a good consumer for many of our dynamic compilation techniques; the fact that our dynamic compiler can compile the code of the virtual machine itself means that it can dynamically optimize the virtual machine code with respect to the application that is running on it. Javas object-oriented nature also facilitates modularity of the design and implementation.
Third, we wanted the system to be useful to a wide audience. The fact that the system is written in Java means that much of the system can be used on any platform that has an implementation of a Java virtual machine. The fact that Joeq supports popular input languages like Java, C, C++, Fortran, and even x86 binary code increases the scope of input programs. We released the system on the SourceForge web site as open source under the Library GNU Public License.
It has been picked up by researchers on five continents for various purposes, among them: automatic extraction of component interfaces, static whole-program pointer analysis, context-sensitive call graph construction, automatic distributed computation, versioned type systems for operating systems, sophisticated profiling of applications, advanced dynamic compilation techniques, system checkpointing, anomaly detection, secure execution platforms and autonomous systems. In addition, Joeq is now used as the basis of the Advanced Compilation Techniques class taught at Stanford University.
Joeq supports two modes of operation: native execution and hosted execution. In native execution, the Joeq code runs directly on the hardware. It uses its own run-time routines, thread package, garbage collector, etc. In hosted execution, the Joeq code runs on top of another virtual machine. Operations to access objects are translated into calls into the reflection library of the host virtual machine.
The user code that executes is identical, and only a small amount of functionality involving unsafe operations is not available when running in hosted execution mode. Hosted execution is useful for debugging purposes and when the underlying machine architecture is not yet directly supported by Joeq. We also use hosted execution mode to bootstrap the system and perform checkpointing, a technique for optimizing application startup times.
Joeq system consists of seven major parts:
- Front-end: Handles the loading and parsing of input files, such as Java class files, SUIF files, and binary object files.
- Compiler: A framework for performing analyses and optimizations on code. This includes the intermediate representation (IR) of our compiler.
- Back-end: Converts the compilers intermediate representation into native, executable code. This code can be output to an object file or written into memory to be executed. In addition, it generates metadata about the generated code, such as garbage collection maps and exception handling information.
- Interpreter: Directly interprets the various forms of compiler intermediate representations.
- Memory Manager: Organizes and manages memory. Joeq supports both explicitly-managed and garbage-collected memory.
- Dynamic: Provides profile data to the code analysis and optimization component, makes compilation policy decisions, and drives the dynamic compiler.
- Run-time Support: Provides runtime support for introspection, thread scheduling, synchronization, exception handling, interfacing to external code, and language-specific features such as dynamic type checking.

Notefish is an extension which makes internet research simple.

Notefish makes internet research simple. Notefish is the easiest way to save, organize and share snippets of internet web pages that you find.

You can customize the resulting notes by moving them around, changing their colors, organizing them into sections, and share them with others - all from your web browser.

People use Notefish for researching purchases, travel, jobs, and other tasks requiring information gathering.