Free hex editor software for linux

Hex-a-hop is a puzzle game based on hexagonal tiles. There is no time limit and no real-time elements.

The objective is simply to destroy all the green hexagonal tiles on each of the 100 levels. As you progress through the game, more types of tiles are introduced which make things more difficult and interesting (hopefully).

The project is built on top of SDL, which is an open-source layer for direct media access.

Gamut is the Volity projects first graphical client application, written in Java and usable on any Java-friendly computer.

Gamut project is still alpha and more useful to developers than players, but rapidly approaching a more generally usable beta.

Volity is a framework for developing online multiplayer games. Servers are written in Perl or Python, and the user interface for each game is written in a combination of SVG and ECMAScript. The client automatically downloads the proper UI for any game, allowing you to play games such as Hex, Fluxx, and Aquarius without any further intervention.

While most current games are board and card games, many different game types can be implemented and deployed within the Volity framework.

Sniff formats hex packets from the tcpdump program and converts them to ASCII to make them easier to read and understand.

Smit is a simple ARP sniffer for switched/unswitched networks.

It works even better on switched networks, because the spoofed sides do not see the duplicated packets.

I based the tool on sources from arpmitm and arprelay and included nice features like automatic ARP MAC query and some improved MAC cache consistence algorithm.

Now you can save the whole relayed traffic to a file (buffered, for heavy traffic and direct write mode included) and analyse it with some hex editor.

The format of the capture file defaults now to pkt which means the captured packets will be prefixed with packet id (number, going from 0) and the captured packet length.

The file can be decoded with the pktview utility which Im still working on. Undef TCPDATA in pktview.c if you dont want the lame tcp-data extracting code

Six is a Hex playing program for Linux/Un*x systems running KDE. Six project has a strong AI, an easy to use GUI and can import emails from Richards PBEM server.
Enhancements:
- An Italian translation was added.

edanator is an intuitive graphical binary and hex calculator. Each nibble is displayed in hex and binary. Clicking on the button (hex nibble or binary bit) changes the value. Bit and nibble shifting is supported via dedicated buttons. The project supports variable widths per word (up to 64- bits), three words (each on a different row), and mathematical operations between words.
Enhancements:
- An endian-ness button for swapping bit labels was added along with a bit reverse function.

Graphics::ColorPicker is a Perl module for WYSIWYG web applications that allow selection of HEX color numbers.

SYNOPSIS

use Graphics::ColorPicker;
or
require Graphics::ColorPicker;

make_page($path_to_images);
send_page($html_txt,$type);
$time_string = http_date($time);
$name = script_name;
$html_text=frames($websafe);
$html_text = msie_frame;
$html_text=picker($darkimg,$liteimg,$size,$bsize,greyimg);
$html_text=no_picker;
$html_text=cp216_ds($clrdot,$border,$square)
$javascript_text = jslib;
$html=make_buttons(%look_n_feel,$url,$active,@buttons,$xtra);
$html_text=pluck($color);

IFF Format Library provides header structures and utility functions for reading and writing data files in the Interchange Files.
The Interchange File Format is a simple structured binary file format consisting of sized and typed chunks of data, selectively readable without having to know the format of each chunk.
This functionality is similar to what XML provides for text documents, and the IFF format can indeed be viewed as a sort of a binary XML. IFFs extensibility is an excellent way of not breaking old applications when the file format changes, making it an excellent choice for your next applications data files.
The IFF is also the simplest and the smallest such data format, ensuring that your files consist of real data rather than overhead and that your code spends more time on real work than on parsing the data file. This library defines the IFF header structures and provides simple algorithms for directly writing many of your objects as chunks and containers.
Installation:
This library can be downloaded from SourceForge, as can its sole prerequisite:
libiff - The library source package.
uSTL - An STL implementation, required.
First, unpack and install uSTL, as described in its documentation. Unpack libiff and run ./configure; make install, which will install the library to /usr/local/lib and headers to /usr/local/include. ./configure --help lists available configuration options, in the usual autoconf fashion. The one thing to be aware of is that by default the library will not be completely conforming to EA85 specification. Why that is so, and why you should take the default options anyway, is discussed in detail in the next section. If you really want to use the original EA85 format, you can to pass --with-bigendian --with-2grain to configure.
Usage:
If you are using C++, chances are you already have an object-oriented design of some kind. You have a collection of objects, related to each other in some way, and you want to write them all to a file in some way. It is, of course, possible to just write them all to the file, one after the other, but that approach makes things difficult if you ever decide to change the structure of those objects, write more or fewer of them, or explain to other people how to read your format. Hence, it is desirable to create some kind of structure in the file, to be able to determine where each objects begins and ends, and what kind of object is where. When using an IFF format, youll make simple objects into chunks, and objects containing other objects into FORMs, LISTs, or CATs.
The first task is to make each of your objects readable and writable through uSTL streams. To do that youll need to define three methods, read, write, and stream_size, and create flow operator overrides with a STD_STREAMABLE macro. Here is a typical example:
#include < iff.h > // iff header includes ustl.h, but doesnt use the namespace.
using namespace ustl; // it is recommended to leave iff:: namespace on.
/// Stores players vital statistics.
class CPlayerStats {
public:
void read (istream& is);
void write (ostream& os) const;
size_t stream_size (void) const;
private:
uint16_t m_HP;
uint16_t m_MaxHP;
uint16_t m_Mana;
uint16_t m_MaxMana;
};
// Since the object is simple, and contains no other objects,
// well make it a simple chunk.
enum { // Define a chunk format for writing this object.
fmt_PlayerStats = IFF_FMT(S,T,A,T)
}; // In a hex editor youll see STAT at the beginning of the object
// making it easy to find when you want to hack something in it.
/// Reads the object from stream p is
void CPlayerStats::read (istream& is)
{
is >> m_HP >> m_MaxHP >> m_Mana >> m_MaxMana;
}
/// Writes the object to stream p os.
void CPlayerStats::write (ostream& os) const
{
os<<less