Plug-in (computing)

From Wikipedia, the free encyclopedia

Jump to: navigation, search

Mozilla Firefox displaying a list of installed plug-ins

In computing, a plug-in (or add-in / addin, plugin, extension or add-on / addon) is a software
component that adds a specific feature to an existing software application. When an application
supports plug-ins, it enables customization. The common examples are the plug-ins used in web
browsers to add new features such as search-engines, virus scanners, or the ability to utilize a
new file type such as a new video format. Well-known browser plug-ins include the Adobe Flash
Player, the QuickTime Player, and the Java plug-in, which can launch a user-activated Java
applet on a web page to its execution on a local Java virtual machine.
A theme or skin is a preset package containing additional or changed graphical appearance
details, achieved by the use of a graphical user interface (GUI) that can be applied to specific
software and websites to suit the purpose, topic, or tastes of different users to customize the look
and feel of a piece of computer software or an operating system front-end GUI (and window
managers).

Contents
[hide]

1 Purpose and examples

2 Mechanism

3 Compared to extensions

4 History

5 See also

6 References

Purpose and examples[edit]

Applications support plug-ins for many reasons. Some of the main reasons include:

to enable third-party developers to create abilities which extend an application

to support easily adding new features

to reduce the size of an application

to separate source code from an application because of incompatible software licenses.

Types of applications and why they use plug-ins:

Audio editors use plug-ins to generate, process and/or analyse sound (Ardour, Audacity)

Email clients use plug-ins to decrypt and encrypt email (Pretty Good Privacy)

Graphics software use plug-ins to support file formats and process images (Adobe
Photoshop, GIMP)

Media players use plug-ins to support file formats and apply filters (foobar2000,
GStreamer, Quintessential, VST, Winamp, XMMS)

Packet sniffers use plug-ins to decode packet formats (OmniPeek)

Remote sensing applications use plug-ins to process data from different sensor types
(Opticks)

Text editors and Integrated development environments use plug-ins to support

programming languages (Eclipse, jEdit, MonoDevelop)

Web browsers use plug-ins (often implementing the NPAPI specification) to play video
and presentation formats (Flash, QuickTime, Microsoft Silverlight, 3DMLW)

Mechanism[edit]

Example Plug-In Framework

As shown in the figure, the host application provides services which the plug-in can use,
including a way for plug-ins to register themselves with the host application and a protocol for
the exchange of data with plug-ins. Plug-ins depend on the services provided by the host
application and do not usually work by themselves. Conversely, the host application operates
independently of the plug-ins, making it possible for end-users to add and update plug-ins
dynamically without needing to make changes to the host application.[1][2]
Programmers typically implement plug-in functionality using shared libraries installed in a place
prescribed by the host application. HyperCard supported a similar facility, but more commonly
included the plug-in code in the HyperCard documents (called stacks) themselves. Thus the
HyperCard stack became a self-contained application in its own right, distributable as a single
entity that end-users could run without the need for additional installation-steps. Programs may
also implement plugins by loading a directory of simple script files written in a scripting
language like Python or Lua.

Compared to extensions[edit]
In the Mozilla Firefox web browser, extensions differ slightly from plug-ins. Firefox supports
plug-ins using NPAPI. An example of this is the Adobe Flash plugin. When the browser
encounters references to content a plug-in specializes in, the data is handed off to be processed
by that plug-in. An extension is an enhancement to the browser that adds new functionality and
often is presented in the form of new user interface elements such as a download manager,
toolbar buttons, or enhancements specific to a particular web site.
The original impetus behind the development of Mozilla Firefox was the pursuit of a small
baseline application, leaving exotic or personalized functionality to be implemented by
extensions to avoid feature creep. This is in contrast to the "kitchen sink" approach in its
predecessors, the Mozilla Application Suite and Netscape 6 and 7.
The same distinction between plug-ins and extensions is in use by other web browsers, such as
Microsoft Internet Explorer, where a typical extension might be a new toolbar, and a plug-in
might embed a video player on the page. Since plug-ins and extensions both increase the utility
of the original application, Mozilla uses the term "add-on" as an inclusive category of
augmentation modules that consists of plug-ins, extensions and themes.

History[edit]
Plug-ins appeared as early as the mid 1970s, when the EDT text editor running on the Unisys
VS/9 operating system using the UNIVAC Series 90 mainframe computers provided the ability
to run a program from the editor and to allow such a program to access the editor buffer, thus
allowing an external program to access an edit session in memory.[3] The plug-in program could
make calls to the editor to have it perform text-editing services upon the buffer that the editor
shared with the plug-in. The Waterloo Fortran compiler used this feature to allow interactive
compilation of Fortran programs edited by EDT.
Very early PC software applications to incorporate plug-in functionality included HyperCard and
QuarkXPress on the Macintosh, both released in 1987. In 1988, Silicon Beach Software included
plug-in functionality in Digital Darkroom and SuperPaint, and Ed Bomke coined the term plugin.[citation needed]