A Go Tournament based on the JXTA Protocols  (go)   
This project aims to create a Go tournament framework based on the JXTA Protocols. This allows players to create and join tournaments and compete over multiple games to ascertain who is the champion Go player. Building this framework will form a good testing ground for distributed computing in the JXTA environment. Some of the challenges involved will be; persistence of player identity within the JXTA environment; failure/recovery techniques and tournament security (i.e. no cheating) to name but a few. As a sub project it is also hoped to explore the challenging problem of creating a computer opponent which can compete with human players. As of today it has proved particularly difficult to create an 'artificially intelligent' go player which can compete with a professional human Go player. There is significant interest in the AI community related to solving this problem. This project hopes to lend a hand by using distributed computing techniques to improve the number of iteration cycles an AI player will evolve though. Quick Links

A Jxta-based Java Incremental Virtual Machine  (jxta-jivm)   
The technologies used for this project are based on JXTA for the collaborative net and J2EE for classical servers needs like safe backup.

A JxtaLoader implementation which loads classes from jnlp files.  (jxse-jnlp-loader)   
The mission of this project is to provide an implementation of JxtaLoader that can load classes and resources from ".jnlp" files in addition to supporting traditional codebases.

A management framework for the Jxta platformA management framework for the Jxta platform  (jump)   
JuMP (Juxta Management Project) is a management framework for the Java implementation of the Java platform. It provides agents which host CIM managed objects, a centralized manager which aggregates management data and a GUI which acts as a management application.

A project for housing the JXTA developer's Guide  (jxta-guide)   
The purpose of this project is to house the JXTA Java Programmer's Guide and to also provide resources for enhancing it.

A reimplementation of standard Java sockets on top of JXTA  (p2psockets)   
P2P Sockets makes it easy to write peer-to-peer applications based on JXTA. P2P Sockets allows programmers to gain much of the power of JXTA, such as NAT and firewall traversal, without being exposed to its complexity. It does this through ports of popular software projects, such as a web server and web services stack, to work on the JXTA peer-to-peer network. This includes a web server (Jetty) that can receive requests and serve content over the peer-to-peer network; a servlet and JSP engine (Jetty and Jasper) that allows existing servlets and JSPs to serve P2P clients; an XML-RPC client and server (Apache XML-RPC) for accessing and exposing P2P XML-RPC endpoints; an HTTP/1.1 client (Apache Commons HTTP-Client) that can access P2P web servers; a gateway (Smart Cache) to make it possible for existing browsers to access P2P web sites; and a WikiWiki (JSPWiki) that can be used to host WikiWikis on your local machine that other peers can access and edit through the P2P network. P2P Sockets also introduces implementations of java.net.Socket and java.net.ServerSocket that can work on the JXTA network as well as a simple, light-weight, distributed, human-friendly, and non-secure DNS system.

Broadcast files through propagation pipes. (w/PicShare demo.)  (jxtacast)   
Broadcast files through propagation pipes. (w/PicShare demo.)

C/C++/C# implementation of JXTA  (jxta-c)   
This project is to provide JXTA core functionality in C/C++ implementation, and targeting to be the base for other language bindings such as C#, Ruby, etc.

Collaborative Stock Trading System  (TradeNet)   
Collaborative Stock Trading System based on a Pseudo-P2P environment, and integrated with Recommendation Framework based on Hebbian Algorithms.

Communicate using voice and/or text, over JXTA peer-to-peer.  (trinytalk)   
Communicate using voice and/or text, over JXTA peer-to-peer.

Device networks, JXTA discovery and interconnect  (jxta-ijxta)   
The main goal of iJXTA is to provide a universal discovery mechanism, and interconnect between JXTA and other device and service description networks. These networks may include SLP, Jini, Apple Rendezvous, etc. While the the initial prototype focuses on Apple Rendezvous, it does not preclude support for other device and service discovery networks.

Digital Money  (dem)   
An open source micropayment system based on Java, JXTA, XML, OpenPGP and SSL. The name "Digital Money" (DM) is reminiscent of the German Mark (Deutsche Mark, DEM, DM), which has been replaced by the Euro.

Directory-based file sharing system with GISP  (jnushare)   
Jnushare2 is a file sharing application based on the GISP.dev.java.net project.

Documentation Project for JXTA  (jxta-docs)   
This project contains static documentation for the JXTA community.

drawboard    
drawboard uses JXTA-sockets to create a client-server whiteboard application so that remote users can share drawings from a user's local desktop.

Eclipse/Equinox Jxta Plugin  (jxta-eclipse)    
The jxta plugin for Eclipse/Equinox aims to provide a lightweight P2P plugin, using jxta core libraries and the cms.

Extendable P2P Forum  (dreamcatcher)   
Extendable P2P Forum

Farm2Fork  (farm2fork)    
Farm2Fork is based on the 1060-NetKernal, JXTA, OpenAdaptor, Hibernate and auto-id(epc) to provide a rich P2P node allowing users to share information between trading partners while retaining posession and ownership of their data.

Global Information Sharing Protocol; an implementation of DHT  (gisp)   
GISP stands for Global Information Sharing Protocol, and it provides a distributed hash table. The features of GISP are scalability, simplicity, and easiness of development. GISP itself does not use broadcasting messages at all. It takes any data with a keyword, and selects one or several peers for the keyword. This is done by calculating a hash value of a keyword and a hash value of a peer ID, then ordering peers in a defined manner. When searching data, a peer sends a query to the selected peer for the search keyword. Data with the same keyword should be stored in the same peer so that other peers can search them.

JAAS Membership Service for JXTA JXSE  (jxse-jaas-membership)   
This project enables developers to leverage existing authentication services (JNDI, LDAP, NIS, as well as WinNT and Unix-based authentication) as well as providing a consistent framework for integrating new authentication services (Liberty, SAML, Passport) including JXTA-specific authentication mechanisms.

Java Evolutionary Framework  (jef)   
JEF, acronym for Java Evolutionary Framework, is a project aimed to both define and implement a genetic programming framework for the Java programming language.

Java Finite State Machines  (JFSM)   
The JFSM project develops a Finite State Machine code base and associated research which speaks to the needs of software designers. Several problems seem to prevent the full realization of the benefits of FSM designs. Numerous FSM-based applications are around, but they are often geared for specific products and applications. Some FSM offerings aim to be of general use, but require applications to be built around just one framework, IDE, or approach and could introduce significant dependencies. Developers still reinvent basic FSM kits for their projects, while it is often not obvious how to mesh a given framework, such as Swing or JSP, with an FSM. Supposed you just want to try out several different state machine tactics, or “port” an FSM fragment to another environment? The effort to develop a distributed, concurrent FSM infrastructure can be significant. JFSM seeks to address some of these issues. Developers can benefit from a variety of FSM kit downloads and, especially, a know-how library on using FSM with various frameworks collected from the participants over time. Different code base alternatives are intended to compliment and collaborate with other FSM providers.

Java RMI on top of JXTA JXSE  (jxse-rmi)   
The JXTA-RMI project allows applications to program to the familiar Remote Method Invocation API of the Java Software Development Kit. Through a few simple switches, an servant object can decide whether it would like to be contacted through standard, socket-based RMI, or through RMI over JXTA pipes.

JXTA Benchmarking Tools Project  (jxta-benchmarking)   
As we move forward to improve performance and scalability of the JXTA implementations, the JXTA bench project serves as a central repository for benchmarks and testing artifacts.

JXTA CMS implementation for JXSE  (JXSE-CMS)   
A simple content management system for JXSE

JXTA code and examples.  (JXTA-Examples)   
This is a project for JXTA code and examples. There are several small projects plus examples from books.

JXTA Commons  (jxta-commons)   
A set of utility libraries for JXTA - like Apache commons

Jxta eXtreme Cube - Fully Distributed Collaboration Platform  (jxcube)   
JXCube is a collaboration platform that supports synchronous and asynchronous collaborative works such as chat, messenger, file sharing or calender. It achievies scalablility, robustness, fully-distribution, security in core level using P2P technology. Moreover, the JXCube includes desktop GUI and collaborative tools called plugin applications. The JXCube offers plugin framework for applications. So, developers can create their own plugin applications easily using it.

JXTA File Sharing application  (jxta-file-sharing-application)    
this project is based on my university's assignment to create P2P file sharing application using JXTA technology, and the purpose of this project is to discuss and improve file sharing in JXTA.

JXTA for Java 2 SE  (JXTA-JXSE)   
The JXTA JSE (JXSE) project is a complete reference implementation of the JXTA protocols built using Java Standard Edition (JSE) 5.0.

JXTA for Java Micro Edition  (jxme)   
The JXTA Java Micro Edition provides a JXTA compatible platform on resource constrained devices using the Connected Limited Device Configuration (CLDC) or the Mobile Information Device Profile 2.0 (MIDP), or Connected Device Configuration (CDC) . The range of devices include the smart phones to PDAs. Using JXTA Java Micro Edition platform, any CLDC/MIDP/CDC device can participate in the JXTA network with any other JXTA device. (JXTA-J2SE, JXTA-C and JXTA-J2ME).

JXTA for Java Micro Edition  (jxta-jxme)   
JXTA for Java Micro Edition

JXTA for Ruby in Constrained Environments  (jxta-ruby)   
Ruby is a prototype-based object-oriented language that is quickly gaining momentum among the web development community. It is a language that is easy to learn and increases the speed of development in comparison to languages such as Java and C. As P2P goes mainstream and becomes incorporated on more handsets, we need to provide support for the JXTA platform outside of the traditional C/C++ and Java space. This has the advantage of allowing quicker development of P2P based mobile applications, as well as bringing both the Ruby developer and the traditional web developer into the fold of the P2P mobile development. Specifically, the goal of this project is to provide a Ruby API for the JXTA protocols. A key requirement of this project is that JXTA Ruby needs to run within constrained environments (handsets). To achieve this, we will bind ruby to the jxta-c implementation. This will limit key aspects of JXTA such as dynamic loading of the code but will allow the Ruby developer to develop P2P based mobile applications on the JXTA platform.

JXTA Network Map a visual network visual utility  (jxta-netmap)   
JXTNetMap a visual network utility, which utilizes a protocol defined by iViewRendezvous to provide visual representation of the JXTA network. Such utility can be a valuable debugging, and network monitoring tool. The visual aspect of this utility is accomplished through use of the open source project ' TouchGraph'. There are also other interesting visual libraries such as WilmaScope which could provide a 3D perspective to the virtual network.

JXTA Protocol Specification  (jxta-spec)   
Provides formal specifications of the JXTA protocols.

JXTA Shell for JXSE  (jxse-shell)   
The JXTA Shell is a programming and debugging tool for JXSE. It provides

JXTA SOAP bindings  (soap)   
JXTA-SOAP is a package which allows SOAP communication over the JXTA Peer-to-Peer network. The design goals of this project are very attractive: 1. Wrapping Web Services in JXTA services. 2. Using JXTA for Web Service discovery and message transport 3. Supporting WSS and WSRF.

JXTA-Archive  (jxta-archive)   
JXTA Archive

jxta-jngi    
P2P Distributed Computing Framework

jxta-peersonal    
A way to Peerocracy

jxta-remote-desktop    
jxta-remote-desktop uses JXTA and the java.awt.Robot class to create a utility to control a remote desktop anywhere, even behind a firewall!

jxta-tradingcenter    
A P2P based Trading Platform

Metadata Search Layer Based on JXTA Content Manager Service  (metasearch)   
Metadata Search Layer Based on JXTA Content Manager Service

Metering/Monitoring UI for JXSE  (jxse-metering)   
Provides metering and monitoring user interface and utilities for JXTA JXSE

myJXTA is a JXTA Technology based collaboration application.  (jxse-myJXTA)   
Designed from the ground up to be easy to use, modify, extend and deploy.

myJXTA is a JXTA Technology based collaboration application.  (myjxta)   
myJXTA is a JXTA Technology based collaboration application.

MyTv P2P  (mytvp2p)   
MyTv P2P is application that enables video streaming sharing throughout a P2P network. This project will develop two basic modules: a P2P client and the MyTv server.

Open Source Research & Analysis  (Seneca)   
This project will be used to host the paper titled "Expanding SOA with JXTA". This paper is about the ways in which JXTA can add value to Service Oriented Architectures. It will be created using the open source software model, the same manner in which JXTA software projects are developed. The finished product will be distributed under the Creative Commons Attribution-NonCommercial-ShareAlike 2.5 license (see: http://creativecommons.org/licenses/by-nc-sa/2.5/ for more info). All community contributions are welcome and will be worked into the fabric of the paper so long as it is relevant and factual. All interested parties are encouraged to participate, as the more people who do the more successful the paper will be.

P2P Distributed Hash-Table  (jxta-meteor)   
The objective of Meteor is to offer a Distributed Hash-table functionality, in the manner of a Peer-to-Peer network, with mechanisms to adapt to the transientand unreliable nature of the peers. The idea is to simplify the transition between the DHT algorithm design and their implementation, and enable express evaluation and deployment. The first DHT algorithm implemented in Meteor was Chord (see http://www.pdos.lcs.mit.edu/chord). In Meteor, the DHT algorithms are implemented as a service and can be reused for any applications that require a mechanism to lookup and query a node that holds information based on attribute/value search parameters. As of January 2005 Meteor also provides a simple implementation of the Content-Addressable Network (CAN). Meteor was integrated with the Squid P2P search infrastructure to provide flexible and robust keyword-based search with guarantees. However the source code provided here does not include the code for Squid, if you are interested please visit http://www.caip.rutgers.edu/TASSL for contact and information on ongoing research in the area of P2P and distributed computing at Rutgers TASSL laboratory.

P2P Plugin Client  (peeranha42)   
eeranha42 is an all-in-one software solution for p2p networks that bases on JXTA(TM) technology. The software consists of two components, the P42 Client and the P42 Development Kit. The client is the core of the software package and has a special plugable architecture. Furthermore it builds up the interface between the p2p network of JXTA(TM) and p2p application. Due to the fact that developing p2p software is generally much more harder and time expensive than developing simple client-server software the client offers an abstract networklayer for easy development of p2p applications in the form of P42 Plugins in shortest time.

P2P Project Based Research Agent  (goop)   
To the optimistic, the Internet can be seen as a vast, globally connected information source. The Internet does contain a myriad of information, some of it is trivial and some of it is invaluable, but it is important to understand how this information is fundamentally organized. If one has a specific need for information, one can use one of the many excellent search engines available; central indices that rely on an active collection of data on the World Wide Web. The problem with using search engines consistently is that they often yield the same information in day to day searches and they are not intelligent enough to learn from each search that you make. If you have a specific topic that you are researching or even just constantly gathering information on, a search engine will often yield the same old results day after day based on the keywords used in the search. While this makes an excellent starting point, the information gathered is often too vast to sift through or just plain irrelevant. What is needed is a smart way to gather the information, and the more automated the process, the more time a user has to actually analyze the resulting information. GOOP takes on the role of an automatic information gathering agent application; an agent that works within the context of your project in order to share and gather data that is increasingly relevant as time goes on. GOOP, as an agent on your machine, will constantly analyze the current project data so that new links, documents, and other sources are completely relevant to your topic. In order to search for this information, the GOOP agent is a node in a peer-to-peer (P2P) network, putting your agent in constant contact and sharing information with other intelligent nodes. This project based approach to Internet data gathering is more suited to academic or hobby-based researchers and has the potential to create an immense network of intelligent nodes sharing pertinent data.

P2p Rmi over Jxta  (Peermi)   
Peermi is an extension of the standard RMI classes to enable true p2p, bidi rmi.

Paper Airplane  (paperairplane)   
Paper Airplane is a Mozilla plugin that empowers people to easily create collaborative communities without setting up servers or spending money. It does this by integrating a web server into the browser itself, including tools to create collaborative online communities that are stored on the machine. Web sites are stored locally on a user's machine. A JXTA peer network is created between all of the Paper Airplane nodes that are running.

RDF-based Metadata Infrastructure for P2P Applications  (edutella)   
RDF-based Metadata Infrastructure for P2P Applications

Reliable Multicast Pipes  (rmp)   
Please refer to the existing project at http://rmp.jxta.org

symbianjxta    
Porting JXTA core to Symbian C++

terrapeer  (TerraPeer)   
TerraPeer is a P2P-based Distributed Virtual Environment (DVE) application build on Java, JXTA and Java3D technology. The conceptual idea of this project is to design an interface to a multi-user virtual space, which runs on a server-independent network.

The Juxta-CAT Project  (juxtacat)   
The jxta-based project, called Juxta-CAT is an effort to use the JXTA architecture to build a job execution-sharing distributed environment. The "client" peers from this network can use this environment to submit/run their own jobs, basically, programs written in Java and stored on signed jar files, which can use nodes reachable from the net. The user submissions are processed by several "broker" nodes, which determine the best candidate node/s to process any received job petition by first analyzing its computational cost: CPU usage, jobs queue, time as edge, average of completed job, etc. Once this evaluation is done, the petition is assigned and executed on the remote peer/s. Finally, the output result from the job execution is returned to the source peer, the owner of the petition.

TINI binding for JXTA platform  (tini)   
The TINI (Tiny Internet Interface) is a Java virtual machine on a stick: * Ethernet interface and TCP/IP stack * Various I/O ports, such as 1-Wire, CAN, I2C, serial, and others * CPU with Java virtual machine all on a SIMM size printed circuit board. Although the TINI supports much of the 1.1 release of the JDK, several features that the standard Java binding of JXTA uses are missing. The goal of this project is to create a modularized Java binding compatible with the TINI that enables TINI devices to participate in JXTA peer-to-peer networking.

UDP via Jxta (not Jxta over UDP)  (vujxdp)   
It all started because one day I wanted to send video and voice over Jxta for a chat application. My model using the Java Media Framework (JMF) was easy to develop. JMF uses the Real Time Transport Protocol (rtp) over UDP. My application uses 2 video channels, 2 voice channels, 2 text/control channels. Since rtp is associated with a control protocol named rcp and Jxta needs two pipe for each TCP/UDP channel, this makes a total of 20 jxta pipes to deal with in a this 2 way-chat application. Needless to say, when I transposed it into Jxta, it quickly became a nightmare to implement. In theory, it is feasible to modify the rtp/rcp to use another transport protocol, such as Jxta, instead of UDP. Jxta, although using TCP/HTTP, behaves much like UDP. It became clear to me that if I proxied UDP over Jxta, it would save me from modifying rtp/rcp, still a difficult prospect. Plus I'd have all the UDP protocols at my disposal. Coupled with proxying TCP as well, it is then theoretically feasible to use anything over Jxta.

UniNet     
UniNet is an open source project created to achieve a freedom decentralized (and anonymous) area used by people/university to share data/process and to rate them.

Universal data and process exchange  (uninet)   
UniNet is an open source project created to achieve a freedom decentralized (and anonymous) area used by people, university to share data/process and to rate them.

venezia-gondola    
venezia-gondola

www  (jxta-www)   
This project contains the look and feel for the jxta site.

y Transaction service for the JXTA platform that uses BTP  (btp-jxta)   
The BTP-JXTA framework provides a transaction service for the JXTA platform. It uses the BTP as a transaction coordination protocol. A few examples exist, which illustrate the use of the framework in practice. The framework is a finished software product, what means it provides all features that I have planned and it is quite stable and robust now. However, there is definitely room for improvements, and as I do not plan to devote much time to the framework in future, I'm willing to give the ownership of the project away, if there is an interest. The BTP specification can be found at the website of OASIS Business Transactions TC.