Free los suenos software for linux

LinuxBIOS project is aimed at replacing the normal BIOS with a little bit of hardware initialization and a compressed Linux kernel that can be booted from a cold start.
The project was started as part of clustering research work in the Cluster Reseach Lab at the Advanced Computing Laboratory at Los Alamos National Laboratory. The primary motivation behind the project was the desire to have the operating system gain control of a cluster node from power on.
Other beneficial consequences of using LinuxBIOS include needing only two working motors to boot (cpu fan and power supply), fast boot times (current fastest is 3 seconds), and freedom from proprietary (buggy) BIOS code, to name a few.
These secondary benefits are numerous and have helped gain support from many vendors in both the high performance computing as well as embedded computing markets.
Note that, on newer systems, there need be no moving parts at all. At LANL, we are building a new no moving parts 16-node cluster to demonstrate this capability. The cluster will fit in a toolbox, run from a battery, boot in 10 seconds, and be controlled from your laptop (which, sadly, will still have a few moving parts).
Enhancements:
- This release adds preliminary support for M50FW040, M29W040B, M50FLW040A, M50FLW040B, M50FLW080A, M50FLW080B, M50FW080, M50FW016, M50LPW116, and M29W010B (all by ST) to flash ROM.

Los Alamos Message Passing Interface is an implementation of the Message Passing Interface (MPI) motivated by a growing need for fault tolerance at the software level in large high-performance computing (HPC) systems.
This need is caused by the vast number of components present in modern HPC systems, particularly clusters. The individual components -- processors, memory modules, network interface cards (NICs), etc. -- are typically manufactured to tolerances adequate for small or desktop systems.
When aggregated into a large HPC system, however, system-wide error rates may be too great to successfully complete a long application run. For example, a network device may have an error rate which is perfectly acceptable for a desktop system, but not in a cluster of thousands of nodes, which must run error free for many hours or even days to complete a scientific calculation.
LA-MPI has two primary goals: network fault tolerance and high performance.
Network fault tolerance is acheived by implementing a highly efficient checksum/retransmission protocol. The integrity of delivered data is (optionally) verified at the user-level using a checksum or CRC. Data that is corrupt (or never delivered) is retransmitted.
As for high performance, LA-MPIs lightweight checksum/retransmission protocol allows us to achieve low latency messaging. Furthermore, the flexible approach taken to the use of redundant data paths in a network-device-rich system leads to high network bandwidth since different messages and/or message-fragments can be sent in parallel along different paths. Also, since LA-MPI is developed for use on the the large systems at Los Alamos National Laboratory we have verified that LA-MPI is scalable to over 3,500 processes.
An alternative solution to the network fault tolerance problem is to use the TCP/IP protocol. We believe, however, that this protocol -- developed to handle unreliable, inhomogeneous and oversubscribed networks -- performs poorly and is overly complex for HPC system messaging, and that LA-MPIs lightweight checksum/retransmission protocol is a more appropriate choice.
Main features:
- Standard compliant (MPI version 1.2 integrated with ROMIO for MPI-IO)
- Highly portable
- Open source (LGPL)
- Thread safe
- Optimized for SMP systems, including NUMA architectures
- Network fault tolerant (data integrity checked at user level)
- Message-fragment striping across multiple network devices
Enhancements:
- Namespace conflicts have been fixed.
- Error detection and handling of fragments has been improved.
- Bugs in memory barriers and spinlocks for x86 and x86_64 architectures have been fixed.
- Profiling and backtracing support have been added.
- Asynchronous I/O has been disabled by default as a workaround for problems with some filesystems.
- Minor timeout bugs have been fixed.

RoadMap is an open source (GPL) program that provides a car navigation for Linux and UNIX. It displays a map of the streets, tracks the position provided by a NMEA-compliant GPS receiver, identifies the street matching this GPS position and announces the name of the crossing street at the next intersection. A rudimentary trip feature allows RoadMap to display some basic navigation information (distance to the destination, direction, speed, etc..). Voice messages are generated that duplicate some of the screen information.
It is possible to display a specific area by providing a (complete or incomplete) postal address, the intersection of two streets or an exact position (longitude / latitude).
The map files used by RoadMap are generated from the TIGER files provided by the US Census Bureau, and thus cover the USA only. The RoadMap map format is a binary format that is sensitive to the endianness of the processor. Maps available on this site cover all the USA and have been generated for a little endian processor (such as the Intel Pentium and StrongARM processors).
RoadMap has been designed to be usable on both a desktop or laptop PC, or on a PDA such as the iPAQ from HP (formely from COMPAQ). It can use either the Gtk 1.2 , Gtk 2.0 or QT graphic library for its user interface. The Qt interface supports the Sharps Zaurus PDA. All these machines share the same endianness and can use the maps provided on this site.
RoadMap is at an early stage of development. At this time there are no routing features implemented yet. The plan for the future is to implement some navigation features similar to those found in commercial street navigation systems. The main limit for implementing routing is the lack of navigation information in the US Census Bureau database (for example one-way street are not indicated). The US Census Bureau has clearly indicated that it does not plan to add these information in the future (the USCB does not need them).
RoadMap uses gpsd for the GPS link and flite (festival lite) for the voice messages. Note that flite can be rebuilt with better voices than the default one (such as a US voice instead of a british one--some may disagree :). See the flite README for more information. Here is an example, courtesy of Scot Wilcoxon:
cd flite make clean # to remove old executable files ./configure --with-vox=cmu_us_kal16
RoadMap comes with its own GPS status screen, which provides an overview of the satellites received and highlights those the GPS has a fix on. This status screen allows for placing the GPS device in a position that optimizes satellite reception, even if that means making the GPS devices screen not accessible.
RoadMap uses a binary file format for representing the maps that is compact enough to allow the storage of many maps on a Compact Flash or MultiMedia card. For example, the map of Los Angeles county takes about 10 Mbytes of flash space. RoadMap comes with a set of tools to convert the US Census bureau data (both the 2000 and 2002 versions) into its own map format. Future versions of the US Census bureau data will be supported as well (usually a 1 or 2 months after the data has been released).
When RoadMap starts, it displays a map of the same area that was displayed on the latest session. Clicking on the map screen triggers a "sign" that displays the name of the street, road or freeway (if any) that is the closest to the mouse hotpoint.
Enhancements:
- This version includes some GUI improvements (the user can redefine the toolbar & menu) and bug fixes.
- Improved maps are now available on the web site, which were built from the TIGER 2004se files.

Kojoney project is a low level interaction honeypot that emulates an SSH server. The daemon is written in Python using the Twisted Conch libraries.

Kojoney is a mix of the spanish word cojon (s/c/k/) and honey. In the spanish language the sentence "estar hasta los cojones" is used to express that you are cloyed. In the past I received many attacks against my SSH server and various of the attacks were very cool (i.e. using my name and sourname to brute force my SSH Server).

In order to catch my attacker I decided to create a honeypot. The attacker stopped his offensives and (currently) I dont known who were the attacker but I realized of which this tool was very cool and I decided to release it to the public.

Geo::Coder::Yahoo is a Perl module with geocode addresses with the Yahoo! API.

SYNOPSIS

Provides a thin Perl interface to the Yahoo! Geocoding API.
use Geo::Coder::Yahoo;

my $geocoder = Geo::Coder::Yahoo->new(appid => my_app );
my $location = $geocoder->geocode( location => Hollywood and Highland, Los Angeles, CA );

ParaView project is an application designed with the need to visualize large data sets in mind. The goals of the ParaView project include the following:
- Develop an open-source, multi-platform visualization application.
- Support distributed computation models to process large data sets.
- Create an open, flexible, and intuitive user interface.
- Develop an extensible architecture based on open standards.
ParaView runs on distributed and shared memory parallel as well as single processor systems and has been succesfully tested on Windows, Linux and various Unix workstations and clusters. Under the hood, ParaView uses the Visualization Toolkit as the data processing and rendering engine and has a user interface written using a unique blend of Tcl/Tk and C++. Please go here for a detailed list of features.
ParaView was created by Kitware in conjunction with Jim Ahrens of the Advanced Computing Laboratory at Los Alamos National Laboratory (LANL). Contributors and developers of ParaView currently include: Kitware, LANL, Sandia National Laboratories, and Army Research Laboratory. ParaView is funded by the US Department of Energy ASCI Views program as part of a three-year contract awarded to Kitware, Inc. by a consortium of three National Labs - Los Alamos, Sandia, and Livermore. The goal of the project is to develop scalable parallel processing tools with an emphasis on distributed memory implementations. The project includes parallel algorithms, infrastructure, I/O, support, and display devices. One significant feature of the contract is that all software developed is to be delivered open source. Hence ParaView is available as an open-source system.
Main features:
- Handles structured (uniform rectilinear, non-uniform rectilinear, and curvilinear grids), unstructured, polygonal and image data.
- All processing operations (filters) produce datasets. This allows the user to either further process or save as a data file the result of every operation. For example, the user can extract a cut surface, reduce the number of points on this surface by masking, and apply glyphs (for example, vector arrows) to the result.
- Contours and isosurfaces can be extracted from all data types using scalars or vector components. The results can be colored by any other variable or processed further. When possible, structured data contours/isosurfaces are extracted with fast and efficient algorithms which make use of the special data layout.
- Vectors fields can be inspected by applying glyphs (arrows, cones, lines, spheres, and various 2D glyphs) to the points in a dataset. The glyphs can be scaled by scalars, vector component or vector magnitude and can be oriented using a vector field.
- A sub-region of a dataset can be extracted by cutting or clipping with an arbitrary plane (all data types), specifying a threshold criteria to exclude cells (all data types) and/or specifying a VOI (volume of interest - structured data types only)
- Streamlines can be generated using constant step or adaptive integrators. The results can be displayed as points, lines, tubes, ribbons, etc., and can be processed by a multitude of filters.
- The points in a dataset can be warped (displaced) with scalars (given a user defined displacement vector) or with vectors (unavailable for non-linear rectilinear grids).
- With the array calculator, new variables can be computed using existing point or cell field arrays. A multitude of scalar and vector operations are supported.
- Data can be probed at a point or along a line. The results are displayed either graphically or as text and can be exported for further analysis.
- ParaView provides many other data sources and filters by default (edge extraction, surface extraction, reflection, decimation, extrusion, smoothing...) and any VTK filter can be added by providing a simple XML description (VTK provides hundreds of sources and filters, see VTK documentation for a complete list).
Enhancements:
- This release adds parallel uniform rectilinear grid volume rendering (vtkImageData).
- It introduces new algorithms for parallel unstructured grid volume rendering.
- Support for hardware accelerated offscreen rendering using OpenGL framebuffers.
- Improved multi-block support.
- Improved AMR support.
- Animation saving with ffmpeg.
- Filters have been added for FLUENT, OpenFOAM, MFIX, LSDyna, and AcuSolve.
- A gradient filter for unstructured data.
- Many other enhancements and bugfixes.